How can I use enum to Binding data in SwiftUI? - enums

Question

I'm trying to bind to an enum instance's rawValue
enum Brand: Int, CaseIterable, Codable {
case toyota = 0
case mazda
case suzuki
}
struct Car {
var brand: Brand
}
struct CarView: View {
#Binding car: Car
var body: some View {
SomeView(selectionInt: $car.brand)
}
}
But I get this error:
Cannot convert value of type 'Binding' to expected argument
type 'Binding'.
If've tried using $car.brand.rawValue instead (in SomeView's parameters) but then I get this error:
Cannot assign to property: 'rawValue' is immutable.
How can i bind my View to the model instance's rawValue?

Answer 1

Using a brandProxy to maintain the integrity of the other Car variables
import SwiftUI
enum Brand: Int, CaseIterable, Codable {
case toyota = 0
case mazda
case suzuki
case unknown
func description() -> String {
var result = "unknown"
switch self {
case .toyota:
result = "toyota"
case .mazda:
result = "mazda"
case .suzuki:
result = "suzuki"
case .unknown:
result = "unknown"
}
return result
}
}
struct CarView: View {
//This makes it mutable
#State var car: Car
var brandProxy: Binding<Int> {
Binding<Int>(
get: {
car.brand.rawValue
},
set: {
car.brand = Brand(rawValue: $0) ?? Brand.unknown
}
)
}
var body: some View {
VStack{
Text(car.brand.description())
SomeView(selectedIndex: brandProxy)
}
}
}

Answer 2

For this kind of binding you need a custom Binding to help SwiftUI to Bind data!
Info: You can not change rawValue of enum because they are immutable!
and also try of changing them in way of Binding would not help you, they are immutable! you can get them not set them!
So with that info you can know why SwiftUI does not want Bind it at fist place! because if SwiftUI make that Binding possible that would be a BIG violation of enum rawValues! then we will try use Binding power in this way that we change the Int of car not Enum. see the code for example.
import SwiftUI
struct ContentView: View {
#State private var selectedCar: Car = Car(brand: Brand.suzuki)
var body: some View {
VStack {
Picker("", selection: $selectedCar.brand) {
ForEach(Brand.allCases, id: \.self) { car in
Text(car.description)
}
}
.pickerStyle(SegmentedPickerStyle())
}
.padding()
CarView(selectionInt: Binding.init(get: { () -> Int in return selectedCar.brand.rawValue },
set: { newValue in
if let unwrappedBrand = Brand(rawValue: newValue) { selectedCar = Car(brand: unwrappedBrand) } }) )
}
}
struct CarView: View {
#Binding var selectionInt: Int
var body: some View {
Text("selected Int: " + selectionInt.description)
.padding()
let selectedCar = (Brand(rawValue: selectionInt)?.description ?? "unknown")
Text( "selected car: " + selectedCar)
.padding()
VStack(spacing: 20.0) {
Button("select toyota") { selectionInt = 0 }
Button("select mazda") { selectionInt = 1 }
Button("select suzuki") { selectionInt = 2 }
}
.font(Font.body.weight(Font.Weight.bold))
}
}
enum Brand: Int, CaseIterable, Codable, CustomStringConvertible {
case toyota = 0
case mazda = 1
case suzuki = 2
var description: String {
switch self {
case .toyota: return "toyota"
case .mazda: return "mazda"
case .suzuki: return "suzuki"
}
}
}
struct Car {
var brand: Brand
}

Answer 3

Where appropriate, I like defining my enums to be String-based. This is especially useful when the data will be saved to Firebase. When I look at the database, I see the actual values instead of 0s, 1s and 2s that I then have to remember/lookup what they actually stand for.
enum Brand: String, CaseIterable, Codable {
case toyota = "Toyota"
case mazda = "Mazda"
case suzuki = "Suzuki"
}
struct Car {
var brand: Brand
}
struct CarView: View {
#State car: Car
var body: some View {
SomeView(with: $car.brand)
}
}
struct SomeView: some View {
#Binding var brand: Brand
...
}
#State makes it mutable in the original View. #Binding allows another view to make changes and propagate them back to the original view. Going back to the OP's original question, it seems that where you say #Binding should have been #State and you should have a #Binding definition in the SomeView definition. So, you were almost there.