Changeset 1723

Timestamp:

07/04/10 21:54:33 (14 years ago)

Author:

andrei

Message:

Changed broken opAssign to assign, plus minor changes to RefCounted?

Files:

• trunk/phobos/std/typecons.d (modified) (6 diffs)

trunk/phobos/std/typecons.d

@@ -46 +46 @@
-Copyright: Copyright the respective authors, 2008-
-License:   $(WEB boost.org/LICENSE_1_0.txt, Boost License 1.0).
-Authors:   $(WEB erdani.org, Andrei Alexandrescu),
-           $(WEB bartoszmilewski.wordpress.com, Bartosz Milewski),
-           Don Clugston,
-           Shin Fujishiro
- */
-module std.typecons;
-import core.stdc.stdlib, std.algorithm, std.array, std.contracts, std.conv,
-    std.metastrings, std.traits, std.typetuple, core.memory;
+version(unittest) import std.stdio;
-
-/**
-Encapsulates unique ownership of a resource.  Resource of type T is
-deleted at the end of the scope, unless it is transferred.  The
-transfer can be explicit, by calling $(D release), or implicit, when
-returning Unique from a function. The resource can be a polymorphic
-class object, in which case Unique behaves polymorphically too.
-
-Example:
-*/
@@ -321 +322 @@
-    }
-    alias field expand;
-    // @@@BUG 2800
-    //alias field this;
-    
-/**
-   Default constructor.
- */
-    this(U...)(U values) if (U.length == 0)
-    {
-        
-    }
-
-/**
-   Constructor taking one value for each field. Each argument must be
-   implicitly assignable to the respective element of the target.
- */
-    this(U...)(U values) if (U.length == Types.length)
-    {
-        foreach (i, Unused; Types)
-        {
@@ -359 +359 @@
-
-/**
-   Comparison for equality.
- */
-    bool opEquals(T)(T rhs) if (is(typeof(T.field)))
-    {
-        static assert(field.length == rhs.field.length,
-                "Length mismatch in attempting to compare a "
-                ~typeof(this).stringof
-                ~" with a "~typeof(rhs).stringof);
-f; field
-
-
+Unused; Types
+
+ield[i]
-        }
-        return true;
-    }
-
-/**
-   Comparison for ordering.
- */
-    int opCmp(T)(T rhs) if (is(typeof(T.field)))
-    {
-        static assert(field.length == rhs.field.length,
-                "Length mismatch in attempting to compare a "
-                ~typeof(this).stringof
-                ~" with a "~typeof(rhs).stringof);
-
-
-
+
+
+
+
+
+
-        }
-        return 0;
-    }
-
+// Should really be opAssign, not assign
-/**
-   Assignment from another tuple. Each element of the source must be
-   implicitly assignable to the respective element of the target.
- */
-opA
-
-noStrings!(T).Result
+a
+
+Types
-        {
-            field[i] = rhs.field[i];
-        }
-    }
+
-/**
-   Takes a slice of the tuple.
-
-   Example:
-
-----
-Tuple!(int, string, float, double) a;
-a.field[1] = "abc";
-a.field[2] = 4.5;
-auto s = a.slice!(1, 3);
@@ -473 +478 @@
-        auto c = Tuple!(int, "a", double, "b")(a);
-        assert(c.field[0] == 1 && c.field[1] == 2);
-    }
-    Tuple!(int, int) nosh;
-    nosh.field[0] = 5;
-    assert(nosh.field[0] == 5);
-    // Tuple!(int, int) nosh1;
-    // assert(!is(typeof(nosh) == typeof(nosh1)));
-    assert(nosh.toString == "Tuple!(int,int)(5, 0)", nosh.toString);
-    Tuple!(int, short) yessh;
- = yessh
+.assign(yessh)
-
-    Tuple!(int, "a", float, "b") x;
-    static assert(x.a.offsetof == x.field[0].offsetof);
-    static assert(x.b.offsetof == x.field[1].offsetof);
-    x.b = 4.5;
-    x.a = 5;
-    assert(x.field[0] == 5 && x.field[1] == 4.5);
-    assert(x.a == 5 && x.b == 4.5);
-
-    {
@@ -2024 +2029 @@
-// Reference semantics
-rc2 = 42;
-assert(rc1 == 42);
-// the pair will be freed when rc1 and rc2 go out of scope
-----
- */
-struct RefCounted(T, RefCountedAutoInitialize autoInit =
-        RefCountedAutoInitialize.yes)
-if (!is(T == class))
-{
-payload_", size_t, "count_") * refCountedStore_
+_payload", size_t, "_count") * _refCountedStore
-
-    private void refCountedInitialize(A...)(A args)
-    {
-   const sz = (*refCountedStore_
+        const sz = (*_refCountedStore
-        auto p = malloc(sz)[0 .. sz];
-    if (sz >= size_t.sizeof && p.ptr)
-        GC.addRange(p.ptr, sz);
-        emplace!T(p[0 .. T.sizeof], args);
-refCountedStore_ = cast(typeof(refCountedStore_
-refCountedStore_.count_
+_refCountedStore = cast(typeof(_refCountedStore
+_refCountedStore._count
-    }
-
-/**
-Returns $(D true) if and only if the underlying store has been
-allocated and initialized.
- */
-    @property bool refCountedIsInitialized() const
-    {
-refCountedStore_
+_refCountedStore
-    }
-
-/**
-Makes sure the payload was properly initialized. Such a call is
-typically inserted before using the payload.
- */
-    void refCountedEnsureInitialized()
-    {
-()
+
-        refCountedInitialize();
-    }
-
-/**
-Constructor that initializes the payload.
-
-Postcondition: $(D refCountedIsInitialized)
- */
-    this(A...)(A args) if (A.length > 0)
-    {
-        refCountedInitialize(args);
-    }
-
-/**
-Constructor that tracks the reference count appropriately. If $(D
-!refCountedIsInitialized), does nothing.
- */
-    this(this)
-    {
-        if (!refCountedIsInitialized) return;
-refCountedStore_.count_
+_refCountedStore._count
-    }
-
-/**
-Destructor that tracks the reference count appropriately. If $(D
-!refCountedIsInitialized), does nothing. When the reference count goes
-down to zero, calls $(D clear) agaist the payload and calls $(D free)
-to deallocate the corresponding resource.
- */
-    ~this()
-    {
-refCountedStore_ || --refCountedStore_.count_
+_refCountedStore || --_refCountedStore._count
-        // Done, deallocate
-refCountedStore_
-   if ((*refCountedStore_).sizeof >= size_t.sizeof && refCountedStore_
-       GC.removeRange(refCountedStore_
-refCountedStore_
-refCountedStore_
+_refCountedStore
+        if (hasIndirections!T && _refCountedStore
+            GC.removeRange(_refCountedStore
+_refCountedStore
+_refCountedStore
-    }
-
-/**
-Assignment operators
- */
-!T
-
-refCountedStore_, rhs.refCountedStore_
+
+
+_refCountedStore, rhs._refCountedStore
-    }
-
-/// Ditto
-    void opAssign(T rhs)
-    {
-        refCountedPayload() = move(rhs);
-    }
-
-/**
-Returns a reference to the payload. If (autoInit ==
@@ -2132 +2137 @@
- */
-    @property ref T refCountedPayload() {
-        static if (autoInit == RefCountedAutoInitialize.yes)
-        {
-            refCountedEnsureInitialized();
-        }
-        else
-        {
-            assert(refCountedIsInitialized);
-        }
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-}
-
-unittest
-{
-    RefCounted!int* p;
-    {
-        auto rc1 = RefCounted!int(5);
-        p = &rc1;
-        assert(rc1 == 5);
-refCountedStore_.count_
+_refCountedStore._count
-        auto rc2 = rc1;
-refCountedStore_.count_
+_refCountedStore._count
-        // Reference semantics
-        rc2 = 42;
-        assert(rc1 == 42);
-        rc2 = rc2;
-refCountedStore_.count_
+_refCountedStore._count
-        rc1 = rc2;
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+