Swift: enum not conforming to Decodable with Binding associated type?

Question

I have the following code:

struct Car: Hashable, Identifiable, Codable {
    var id = UUID()
    var year:Int
    var make:String
    var model:String
    var notes:String?
    
    static var testCars:[Car] {
        return [
            Car(year: Int.random(in: 1990...2023), make: "Honda", model: "S800"),
            Car(year: Int.random(in: 1990...2023), make: "Honda", model: "Civic"),
        ]
    }
}



enum CarViewRouter:Hashable, Identifiable, Codable {
    
    static func == (lhs: CarViewRouter, rhs: CarViewRouter) -> Bool {
        
        var lhsCarId:UUID
        switch lhs {
        case .car(let car):
            lhsCarId = car.id
        }
        
        var rhsCarId:UUID
        switch rhs {
        case .car(let car):
            rhsCarId = car.id
        }
        
        return lhsCarId == rhsCarId
        
    }
        
    var id: UUID {
        switch self {
        case .car(let car):
            return car.id
        }
    }
    
    case car(Binding<Car>)
}



struct ContentView: View {
    
    @State var cars = [Car]()
    @State var path = NavigationPath()
    
    var body: some View {
        
        NavigationStack {
            VStack {
                ForEach($cars) { $car in
                    Button {
                        path.append(CarViewRouter.car($car))
                    } label: {
                        Text(car.model)
                    }
                }
            }
            .task {
                cars = Car.testCars
            }
            .navigationDestination(for: CarViewRouter.self) { d in
                switch d {
                case .car(let car):
                    CarDetails(car: car)
                }
            }
        }
        
    }
    
}



struct CarDetails:View {
    
    @Binding var car:Car
    
    var body: some View {
    
        Text("\(car.make) - \(car.model) - \(car.year)")
        
    }
    
    
}

I am unable to make it compile. Errors:

Type 'CarViewRouter' does not conform to protocol 'Decodable'

Type 'CarViewRouter' does not conform to protocol 'Encodable'

Type 'CarViewRouter' does not conform to protocol 'Hashable'

How can I make the CarViewRouter as defined conform to those protocols so that it compiles?

[added the entire code to provide complete context. I was trying to pass in a Car so that a subview could eventually edit it...]

Answer 1

I ended up switching to reference type, kept navigation path router enum approach, and used a navigation link with the router. Seems to be working fine.

@main
struct architecturesApp: App {
    
    @State private var dealership = Dealership()
    
    var body: some Scene {
        WindowGroup {
            DealershipView()
                .environment(dealership)
        }
    }
}




@Observable final class Car: Identifiable {
    
    var id = UUID()
    var year:Int
    var make:String
    var model:String
    
    var hashValue: Int {
        return id.hashValue
    }
    
    init(year: Int, make: String, model: String) {
        self.year = year
        self.make = make
        self.model = model
    }
    
}

@Observable final class Dealership {
    
    var cars:[Car] = [
        Car(year: 1, make: "make 1", model: "model 1" ),
        Car(year: 2, make: "make 2", model: "model 2" ),
        Car(year: 3, make: "make 3", model: "model 3" )
    ]
    
}

enum CarViewsRouter: Hashable, Equatable, Identifiable {
    
    var id: ObjectIdentifier {
        switch self {
        case .car(let c):
            return c.id
        }
    }
    
    static func == (lhs: CarViewsRouter, rhs: CarViewsRouter) -> Bool {
        lhs.id == rhs.id
    }
    
    func hash(into hasher: inout Hasher) {
        switch self {
        case .car(let c):
            hasher.combine(c.id)
        }
    }
    
    case car(Car)
}


struct DealershipView: View {
    
    @Environment(Dealership.self) private var dealership
    @State var navPath = NavigationPath()

    var body: some View {
        NavigationStack {
            List(dealership.cars) { car in
                NavigationLink(value: CarViewsRouter.car(car)) {
                    Text("\(car.model). YEAR: \(car.year)")
                }
            }
            .navigationDestination(for: CarViewsRouter.self) { d in
                switch d {
                case .car(let car):
                    CarView(car: car)
                }
            }
        }
        
    }
    
}


struct CarView: View {
    
    @Bindable var car:Car
    
    var body: some View {
        Button(action: {
            car.year = Int.random(in: 1...100)
        }, label: {
            Text("CAR: \(car.model). Year: \(car.year)")
        })
    }
    
}