क्या केवल स्थिर गुणों का उपयोग करके दो structs के बीच एक द्विपक्षीय संबंध स्थापित करना संभव है?

Question

मेरे उपयोग के मामले निम्नलिखित मॉडल पर आधारित है:

struct Person { 
    let name: String 
    let houses: [House] 
} 

struct House { 
    let owner: Person 
} 

अब, आदर्श मैं एक द्विदिश रिश्ता है कि एक ही स्वामी है, जहां एक मालिक भी अपने सभी घरों को पता होना चाहिए के लिए हर घर की आवश्यकता है बनाए रखने के लिए करना चाहते हैं।

उपरोक्त डेटा संरचनाओं का उपयोग करना, क्या House और Person के उदाहरण बनाना संभव है कि दोनों के बीच एक रिश्ता है और ऑब्जेक्ट्स अनिवार्य रूप से एक-दूसरे पर इंगित कर रहे हैं?

मुझे लगता है कि इसका वाक्यांश पहले से ही कुछ भ्रामक है, क्योंकि struct के मूल्य अर्थशास्त्र के कारण, वे वास्तव में कहीं भी इंगित नहीं करते हैं बल्कि केवल मूल्यों की प्रतियां रखते हैं। ऐसा लगता है कि यह स्पष्ट होना चाहिए कि इन दोनों वस्तुओं को द्विपक्षीय संबंधों के साथ बनाना संभव नहीं है, लेकिन मैं अभी भी यह सुनिश्चित करना चाहता हूं और यहां इन प्रश्न पूछें!

एक स्पष्ट समाधान भी जब उन्हें घोषित let के बजाय var का उपयोग कर houses और owner चर बनाने के लिए हो सकता है, तो रिश्ते प्रत्येक struct के प्रारंभकर्ता में बनाए रखा जा सकता है:

struct Person { 
    let name: String 
    var houses: [House] 

    init(name: String, houses: [House]) { 
    self.name = name 
    self.houses = houses 
    self.houses = houses.map { (house: House) in 
     var newHouse = house 
     newHouse.owner = self 
     return newHouse 
    } 
    } 
} 


struct House { 
    var owner: Person 

    init(owner: Person) { 
    self.owner = owner 
    var newHouses = self.owner.houses 
    newHouses.append(self) 
    self.owner = Person(name: owner.name, houses: newHouses) 
    } 
} 

हालांकि, क्या हुआ अगर मैं houses और owner निरंतर रखना चाहते हैं? जैसा कि मैंने कहा, ऐसा लगता है कि यह संभव नहीं है, लेकिन मुझे आश्चर्य है कि क्या यह हासिल करने के लिए कुछ फैंसी (शायद कार्यात्मक) तरीका है? मैं lenses के बारे में सोच रहा था, जिसका उपयोग गेटर्स और सेटर्स के रूप में किया जा सकता है जब अपरिवर्तनीय मॉडल से निपटने के लिए।

Answer 1

जो आप वर्णन कर रहे हैं वह एक भाषा सुविधा की तुलना में ओआरएम की तरह लगता है, और यह भी structs जैसे मूल्य प्रकारों को संभालने के लिए उपयुक्त नहीं है। आप भाषा को यह जानने की उम्मीद कैसे करते हैं कि ownerhouses की व्यस्त रिश्ते की संपत्ति है और इसके अनुसार बनाए रखा जाना चाहिए? यह कुछ ऐसा है जिसे कोड के साथ लागू करने की आवश्यकता है अकेले स्विफ्ट भाषा के साथ संभव नहीं है।

ऐसा लगता है कि आप किसी प्रकार का मॉडल ऑब्जेक्ट ग्राफ़ बनाए रखने की कोशिश कर रहे हैं, जो एक समस्या है जिसे कई बार हल किया गया है। आपको Realm DB और Core Data पर एक नज़र डालना चाहिए, जिनमें से दोनों प्रबंधित द्विपक्षीय संबंध प्रदान करते हैं। हालांकि आप पाएंगे कि इनमें से कोई भी structs के साथ लागू नहीं किया गया है। मूल्य प्रकारों का उपयोग करने में समस्या यह है कि वे कॉपी-ऑन-राइट हैं। जैसे ही आप ऑब्जेक्ट ग्राफ़ में एक स्ट्रक्चर को म्यूट करते हैं, आपको अपनी सभी संबंधित चीजों को नई, उत्परिवर्तित प्रतिलिपि में पुन: असाइन करना होगा, जिसके बाद बदले में उत्परिवर्तित किया जाएगा और उनके संबंधित structs को अपडेट करने की आवश्यकता होगी। संदर्भ अर्थशास्त्र (कक्षाएं) ऑब्जेक्ट ग्राफ़ को अधिक आसान बनाते हैं क्योंकि उत्परिवर्तन नए उदाहरण नहीं बनाते हैं।

Answer 2

आप जो चाहते हैं वह structs का उपयोग करना संभव नहीं है। आपका वर्तमान समाधान (var के साथ) काम नहीं करता है जैसा कि आपको लगता है कि यह करता है: सभी मान स्वतंत्र प्रतियां हैं। निम्न उदाहरण पर विचार करें:

let p = Person(name: "Nick", houses: []) 
let h = House(owner: p) 
h.owner.houses 
p.houses 

क्योंकि प्रत्येक प्रतिलिपि स्वतंत्र है, इसका मतलब है ph.owner के रूप में ही नहीं है।

यदि आपको एक द्विपक्षीय संबंध की आवश्यकता है, तो आपको weak पॉइंटर्स (संदर्भ चक्र को तोड़ने के लिए) के साथ वस्तुओं का उपयोग करना चाहिए। वैकल्पिक रूप से, आप यह देखने के लिए सोच सकते हैं कि आपको द्विपक्षीय संबंध की आवश्यकता है या नहीं।