İç içe geçmiş nesneler ve oluşturucular

Question

ile ölçülemeyen değer nesneleri, şu anda değiştirilemeyecek şekilde belgelendirilmiş ve nesneler üzerinde değişiklik yapma yöntemleri ve sağlamayan çok sayıda değer nesnesine sahip büyük bir sisteme sahibiz. Kodun bazı bölümlerini yeniden yazarken, sadece sınıfların değişmez olduğunu belgelemek değil, aynı zamanda bunları değişmez olarak nitelendirmek için iyi bir egzersiz olacağını düşündüm. yuvalanmış nesne ile

Bir Değer nesnesi şuna benzer:

immutable class Nested 
{ 
    int i; 

    public this(int i) immutable 
    { 
     this.i = i; 
    } 
} 

immutable class Value 
{ 
    private Nested nested_; 

    public immutable(Nested) nested() const 
    { 
     return this.nested_; 
    } 

    package this(immutable(Nested) nested) 
    { 
     this.nested_ = nested; 
    } 
} 

zaman değerlerinden herhangi bir değişiklik biz özelliklerini bir kopyasını oluşturmak ve değiştirmek için bir inşaatçı kullanmak yapılması gerekmektedir. Şimdiye kadar çok iyi - ama iç içe geçmiş nesneler söz konusu olduğunda başım belaya giriyor. Oluşturucudan bir kopya oluşturmak için orijinal nesneyi kullanmak yalnızca değişmez iç içe geçmiş nesneyi alabilir ve saklayabilir. Ancak, yapımcı iç içe geçmiş nesneyi yenisine nasıl değiştirebilir?

std.typecons'tan Rebindable ile geldim - ama bunun iyi bir uygulama olup olmadığından emin değilim.

class Builder 
{ 
    import std.typecons : Rebindable; 

    Rebindable!(immutable(Nested)) nested_; 

    this() 
    { 
     this.nested_ = null; 
    } 

    this(immutable(Value) value) 
    { 
     this.nested_ = value.nested; 
    } 

    public void nested(immutable(Nested) nested) 
    { 
     this.nested_ = nested; 
    } 

    public immutable(Value) value() const 
    { 
     return new immutable Value(this.nested_); 
    } 
} 

void main() 
{ 
    import std.stdio : writefln; 

    immutable value = new immutable Value(new immutable Nested(1)); 

    writefln("i = %d", value.nested.i); 

    auto builder = new Builder(value); 
    immutable newNested = new immutable Nested(2); 
    builder.nested = newNested; 

    writefln("i = %d", builder.value.nested.i); 
} 

Değişmezlik ve yapının doğruluğu hakkında çok fazla düşünür müsünüz?

Selamlar,

Rooney

Answer 1

Rebindable ile olan çözüm Tamam, ben bu başarmak için en iyi yolu olarak considere. Başka bir olası çözüm ise nested_ mutable ve casts kullanmaktır, ancak bu çok zarif ve güvenli değildir:

class Builder 
{ 
    import std.typecons : Rebindable; 
    union 
    { 
     private Nested m_nested_; 
     immutable(Nested) nested_; 
    } 

    this() 
    { 
     this.nested_ = null; 
    } 

    this(immutable(Value) value) 
    { 
     this.nested_ = value.nested(); 
    } 

    public void nested(immutable(Nested) nested) 
    { 
     this.m_nested_ = cast(Nested)nested; 
    } 

    public immutable(Value) value() const 
    { 
     return new immutable Value(this.nested_); 
    } 
}