Jak uzyskać dostęp przekazał argument Enum w Swift 3 - swift

Mam problemy z uzyskaniem dostępu do parametru, który jest przekazywany z wyliczeniem.

Generic RequestType, więcej zostanie uwzględnionych.

enum RequestType {
case flagging(api : FlaggingRequestType)
}

Oto moje wyliczenie, które akceptuje inny FlaggingRequestType (inne wyliczenie, które akceptuje parametr ciągu)

enum FlaggingRequestType {
case getFlag(api : String)
}

protocol Requestable {
var requestType : RequestType { get set }
}

Tutaj tworzę moją prośbę dotyczącą flagowania

let flaggingRequest = RequestBuilder.buildFlaggingRequest(flagRequest: .getFlag(api: "http://www.apiworld.com"))

Oto moja metoda, aby faktycznie wysłać żądanie z innej metody.

func sendRequest(for apiRequest : Requestable) {
switch apiRequest.requestType {
case .flagging:
self.flaggingAPI(for: apiRequest)
}
}

Problem polega na tym, że nie mogę dowiedzieć się, jak uzyskać dostęp do wartości przekazanej w pliku api parametr znaleziony w apiRequest/ flaggingRequest. czy to możliwe? Mam nadzieję, że to jasne :)

Odpowiedzi:

3 dla odpowiedzi № 1

Oto https://appventure.me/2015/10/17/advanced-practical-enum-examples/#sec-1-5

func sendRequest(for apiRequest : Requestable) {
switch apiRequest.requestType {
case .flagging(let api):
// access api value here
self.flaggingAPI(for: apiRequest)
}
}

---

2 dla odpowiedzi nr 2

„Zagnieżdżone” dopasowanie do wzorca i wiązanie wartości: case .one(.two(let val))

Jeśli dla danego wystąpienia typu, który jest zgodny z RequestableTwoim jedynym celem jest uzyskanie dostępu do powiązanych plików String wartość „wewnętrznej” FlaggingRequestType przykład (dla znanego wewnętrznego case), można użyć zagnieżdżonego dopasowywania i wiązania wzorców w pojedynczym pliku casenp. używany nie tylko w switch kup, powiedzmy if komunikat.

// your example setup
enum FlaggingRequestType {
case getFlag(api : String)
}

protocol Requestable {
var requestType : RequestType { get set }
}

enum RequestType {
case flagging(api : FlaggingRequestType)
}

// dummy type conforming to "Requestable"
struct Foo : Requestable {
var requestType: RequestType =
.flagging(api: .getFlag(api: "http://www.apiworld.com"))
}

// Q: how to find the nested "http://www.apiworld.com" String
//    from a "Foo" instance?
let foo = Foo()

// A: use nested pattern matching, e.g. in a single "if" statement
if case .flagging(.getFlag(let api)) = foo.requestType {
print(api) // http://www.apiworld.com
}

Możesz naturalnie skorzystać z zagnieżdżonego dopasowania wzorców również w przypadku switch komunikat:

switch foo.requestType {
case .flagging(.getFlag(let api)): print(api) // http://www.apiworld.com
// ...
default : () // in non-exhaustive pattern matching above
}

W przypadku powiązanej wartości różnych typów FlaggingRequestType są tego samego typu, a także tego samego oczekiwanego użycia, to zagnieżdżone powiązanie może być użyteczną alternatywą dla kilku zagnieżdżonych switch sprawozdania. Na przykład, jeśli rozszerzysz powyższą przykładową konfigurację do:

enum FlaggingRequestType {
case getFlag(api : String)
case getHandle(api : String)
case getId(id: Int)
}

Moglibyśmy zastosować zagnieżdżone dopasowanie wzorców w pojedynczym pliku switch oświadczenie, gdzie jeden case może obejmować wiązanie skojarzonych wartości dla kilku różnych przypadków wewnętrznego wyliczenia, biorąc pod uwagę, że te skojarzone wartości mają ten sam typ.

switch foo.requestType {
case .flagging(.getFlag(let api)),
.flagging(.getHandle(let api)): print(api) // api is "String", a flag or a handle
case .flagging(.getId(let id)):      print(id)  // id is "Int"
// ...
default : () // in case of non-exhaustive pattern matching above
}

---

Na koniec zwróć uwagę, że możesz rozważyć użycie typów ogólnych z ograniczeniem typu dla swojego sendRequest zamiast wpisywać protokół, który ma być używany jako typ.

func sendRequest<T: Requestable>(for apiRequest : T) { /* ... */ }

---

1 dla odpowiedzi nr 3

Ponieważ jest zagnieżdżony, będziesz musiał wykonać zagnieżdżone przypadki przełączania, na przykład:

switch apiRequest {
case .flagging(let value):
switch value {
case .getFlag(let api):
print(api) // api is the string passed in the associated value
break
}
break
}

---