एप्पल स्विफ्ट: प्रकार कास्टिंग जेनेरिक्स

Question

मैं कुछ स्विफ्ट कोड लिख रहा हूँ जहाँ मैं एक सामान्य प्रकार युक्त एक सरणी है:

let _data: Array<T> = T[]() 

मेरी कोड में बाद में मैंने सरणी में संग्रहीत प्रकार निर्धारित करने की जरूरत है। मैंने documentation में वर्णित प्रकार कास्टिंग तकनीक का उपयोग करने की कोशिश की (हालांकि यह जेनरिक के लिए उपयोग नहीं किया गया था)।

switch self._data { 
case let doubleData as Array<Double>: 
    // Do something with doubleData 
case let floatData as Array<Float>: 
    // Do something with floatData 
default: 
    return nil // If the data type is unknown return nil 
} 

निम्न त्रुटि में ऊपर स्विच बयान परिणाम संकलन पर:

1. While emitting IR SIL function @_TFC19Adder_Example___Mac6Matrix9transposeUS_7Element__fGS0_Q__FT_GSqGS0_Q___ for 'transpose' at /code.viperscience/Adder/src/Adder Library/Matrix.swift:45:3 :0: error: unable to execute command: Segmentation fault: 11 :0: error: swift frontend command failed due to signal (use -v to see invocation) Command /Applications/Xcode6-Beta2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swift failed with exit code 254

किसी को पता है कि कैसे मैं आदेश विशिष्ट कार्रवाई करने में अपनी वास्तविक प्रकार करने के लिए अपने सामान्य डेटा डाली कर सकते हैं?

Answer 1

मान लीजिए आप बटन की एक सरणी है:

let views: [NSView] = [NSButton(), NSButton(), NSButton()] 

आप इन डाले उपयोग कर सकते हैं:

let viewsAreButtons = views is [NSButton] // returns true 
let buttonsForSure = views as! [NSButton] // crashes if you are wrong 
let buttonsMaybe = views as? [NSButton] // optionally set 

यदि आप इस रूप में उपयोग करने का प्रयास करते हैं नीचे की तरह चुड़ैल मामला, यह काम नहीं करेगा। कंपाइलर (स्विफ्ट 1.2 एक्सकोड 6.3 बी 1) कहता है: "डाउनकास्ट पैटर्न प्रकार [एनएसबटन] का उपयोग नहीं किया जा सकता है।"

switch views { 
    case let buttons as [NSButton]: 
    println("Buttons") 
    default: 
    println("something else") 
} 

इसे एक सीमा कहते हैं। अपने उपयोग के मामले के साथ एक रडार फ़ाइल करें। स्विफ्ट टीम वास्तव में फीडबैक सुनने के लिए seams। यदि आप वास्तव में इसे काम पर लेना चाहते हैं, तो आप अपने पैटर्न मिलान ऑपरेटर को परिभाषित कर सकते हैं।

struct ButtonArray { } 
let isButtonArray = ButtonArray() 

func ~=(pattern: ButtonArray, value: [NSView]) -> Bool { 
    return value is [NSButton] 
} 

फिर इस काम करता है::

switch views { 
    case isButtonArray: 
     println("Buttons") // This gets printed. 
    default: 
    println("something else") 
} 

यह एक खेल का मैदान में प्रयास करें इस मामले में यह कुछ इस तरह होगा। आशा करता हूँ की ये काम करेगा!

Answer 2

तेज में, as ऑपरेटर सी ++ में dynamic_cast की तरह कुछ है, जो किया जा सकता है नीचे एक वस्तु डाली है।

आप प्रकार A का एक उद्देश्य a है कहो, और आप let a as B लिख सकते हैं केवल जब प्रकार B टाइप करने के लिए A समान है, या BA की एक उप-वर्ग है।

आपके मामले में, स्पष्ट रूप से Array<T> को हमेशा Array<Double> या Array<Float> पर डाला नहीं जा सकता है, इसलिए संकलक त्रुटियों की रिपोर्ट करता है।

एक साधारण ठीक कन्वर्ट करने के लिए है AnyObject पहले, और फिर Array<Double> या Array<Float> को खिन्न:

let anyData: AnyObject = self._data; 
switch anyData { 
case let doubleData as? Array<Double>: // use as? operator, instead of as, 
             // to avoid runtime exception 
    // Do something with doubleData 
case let floatData as? Array<Float>: 
    // Do something with floatData 
default: 
    return nil // If the data type is unknown return nil