मैं एक ऐसी संरचना को कैसे कार्यान्वित करूं जो आजीवन एनोटेशन के साथ एक सामान्य वेक्टर लेता है?

Question

निम्नलिखित compiles ठीक:

pub struct Reader<'a> { 
    position: uint, 
    data: &'a [u8] 
} 

यह एक पाठक है कि एक संदर्भ के रूप में प्रकार u8 का एक वेक्टर (वास्तव में एक टुकड़ा) लेता है, और मैं जीवन भर निर्दिष्ट करें।

हालांकि यह वही नहीं है जो मैं चाहता हूं। मैं संरचना को सामान्य बनाने में सक्षम होना चाहता हूं, और इससे भी अधिक सटीक होना चाहता हूं, मैं यह इंगित करना चाहता हूं कि प्रकार किसी भी चीज का टुकड़ा होना चाहिए। मैं शुरुआत के लिए यह करने की कोशिश की:

pub struct Reader<'a, T> { 
    position: uint, 
    data: &'a T 
} 

यह T निरूपित नहीं है एक टुकड़ा हो सकता है, लेकिन यह पहले से ही एक संदेश के साथ विफल हो रहा है:

पैरामीटर प्रकार T काफी देर तक नहीं रह सकता है; एक स्पष्ट जीवन T:'a बाध्य जोड़ने पर विचार करें ...

ठीक है तो मैं बस जीवन को निर्दिष्ट करने के लिए किया था।

लेकिन अब मेरी समस्या यह है कि मैं इसे प्रकार के टुकड़े के सामान्य कैसे बना सकता हूं और जीवनकाल प्राप्त कर सकता हूं? मैंने Reader<'a, T: 'a Vec> और T: 'a [T] जैसी चीजों की कोशिश की लेकिन मुझे नहीं पता कि मुझे यह कैसे इंगित करना है और आधिकारिक मार्गदर्शिका इस तरह के मामले से निपटने लगती नहीं है।

मैं बस एक पाठक बनाना चाहता हूं जो इसे उधार लेकर किसी भी प्रकार का टुकड़ा लेता है, और डेटा (केवल पढ़ने के तरीकों में) पर काम करने के तरीकों को प्रदान करता है।

Answer 1

में थोड़ा और अधिक कोशिश कर के बाद, मैं अंत में यह समझ से बाहर:

pub struct Reader<'a, T: 'a> { 
    position: uint, 
    data: &'a [T] 
} 

यह परिभाषित करता है पाठक का data प्रकार Slice<T> का होना ([] टुकड़ा के नाम हैं) और &'a उधार डेटा के लिए जीवन भर का उल्लेख है।

अब मैं इस तरह सामान को लागू कर सकते हैं:

impl<'a, T> Reader<'a, T> { 
    pub fn from_data(bytes: &'a[T]) -> Reader<'a, T> { 
     Reader { 
      position: 0, 
      data: bytes 
     } 
    } 
} 

Answer 2

सीधे जवाब देने के लिए इच्छुक नहीं है, यह सिर्फ है कि मैं तो जवाब जब मैं अपने ही समस्या का एक जवाब के लिए देख रहा था इस में आए: कैसे एक लागू करने के लिए सामान्य प्रकार की बाधा और एक संरचना के क्षेत्र में आजीवन बाधा।

(यहाँ काम कर समाधान मैं के साथ आया है।)

use std::io::Writer; 

// This specifies lifetime constraint of 'a 
// Type W must implement the Writer trait 
// Type W has the lifetime 'a (the same as the related struct instance) 
pub struct Foo<'a, W: 'a + Writer> { 
    writer: &'a mut W 
}