swift-protobuf/Sources/SwiftProtobuf/PathDecoder.swift

// Sources/SwiftProtobuf/PathDecoder.swift - Path decoder
//
// Copyright (c) 2014 - 2023 Apple Inc. and the project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See LICENSE.txt for license information:
// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt
//
// -----------------------------------------------------------------------------
///
/// Decoder which sets value of a field by its path.
///
// -----------------------------------------------------------------------------

import Foundation

/// Describes errors can occure during decoding a proto by path.
public enum PathDecodingError: Error {

    /// Describes a mismatch in type of the fields.
    ///
    /// If a value of type A is applied to a path with type B.
    /// this error will be thrown.
    case typeMismatch

    /// Describes path is not found in message type.
    ///
    /// If a message has no field with the given path this
    /// error will be thrown.
    case pathNotFound
}

extension Message {
    static func number(for field: String) -> Int? {
        guard let type = Self.self as? any _ProtoNameProviding.Type else {
            return nil
        }
        guard
            let number = Array(field.utf8).withUnsafeBytes({ bytes in
                type._protobuf_nameMap.number(forProtoName: bytes)
            })
        else {
            return nil
        }
        if type._protobuf_nameMap.names(for: number)?.proto.description != field {
            return nil
        }
        return number
    }

    static func name(for field: Int) -> String? {
        guard let type = Self.self as? any _ProtoNameProviding.Type else {
            return nil
        }
        return type._protobuf_nameMap.names(for: field)?.proto.description
    }
}

// Decoder that set value of a message field by the given path
struct PathDecoder<T: Message>: Decoder {

    // The value should be set to the path
    private let value: Any?

    // Field number should be overriden by decoder
    private var number: Int?

    // The path only including sub-paths
    private let nextPath: [String]

    // Merge options to be concidered while setting value
    private let mergeOption: Google_Protobuf_FieldMask.MergeOptions

    private var replaceRepeatedFields: Bool {
        mergeOption.replaceRepeatedFields
    }

    init(
        path: [String],
        value: Any?,
        mergeOption: Google_Protobuf_FieldMask.MergeOptions
    ) throws {
        if let firstComponent = path.first,
            let number = T.number(for: firstComponent)
        {
            self.number = number
            self.nextPath = .init(path.dropFirst())
        } else {
            throw PathDecodingError.pathNotFound
        }
        self.value = value
        self.mergeOption = mergeOption
    }

    private func setValue<V>(_ value: inout V, defaultValue: V) throws {
        if !nextPath.isEmpty {
            throw PathDecodingError.pathNotFound
        }
        if self.value == nil {
            value = defaultValue
            return
        }
        guard let castedValue = self.value as? V else {
            throw PathDecodingError.typeMismatch
        }
        value = castedValue
    }

    private func setRepeatedValue<V>(_ value: inout [V]) throws {
        if !nextPath.isEmpty {
            throw PathDecodingError.pathNotFound
        }
        var castedValue: [V] = []
        if self.value != nil {
            guard let v = self.value as? [V] else {
                throw PathDecodingError.typeMismatch
            }
            castedValue = v
        }
        if replaceRepeatedFields {
            value = castedValue
        } else {
            value.append(contentsOf: castedValue)
        }
    }

    private func setMapValue<K, V>(
        _ value: inout [K: V]
    ) throws {
        if !nextPath.isEmpty {
            throw PathDecodingError.pathNotFound
        }
        var castedValue: [K: V] = [:]
        if self.value != nil {
            guard let v = self.value as? [K: V] else {
                throw PathDecodingError.typeMismatch
            }
            castedValue = v
        }
        if replaceRepeatedFields {
            value = castedValue
        } else {
            value.merge(castedValue) { _, new in
                new
            }
        }
    }

    private func setMessageValue<M: Message>(
        _ value: inout M?
    ) throws {
        if nextPath.isEmpty {
            try setValue(&value, defaultValue: nil)
            return
        }
        var decoder = try PathDecoder<M>(
            path: nextPath,
            value: self.value,
            mergeOption: mergeOption
        )
        if value == nil {
            value = .init()
        }
        try value?.decodeMessage(decoder: &decoder)
    }

    mutating func handleConflictingOneOf() throws {}

    mutating func nextFieldNumber() throws -> Int? {
        defer { number = nil }
        return number
    }

    mutating func decodeSingularFloatField(value: inout Float) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularFloatField(value: inout Float?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedFloatField(value: inout [Float]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularDoubleField(value: inout Double) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularDoubleField(value: inout Double?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedDoubleField(value: inout [Double]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularInt32Field(value: inout Int32) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularInt32Field(value: inout Int32?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedInt32Field(value: inout [Int32]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularInt64Field(value: inout Int64) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularInt64Field(value: inout Int64?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedInt64Field(value: inout [Int64]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularUInt32Field(value: inout UInt32) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularUInt32Field(value: inout UInt32?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedUInt32Field(value: inout [UInt32]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularUInt64Field(value: inout UInt64) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularUInt64Field(value: inout UInt64?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedUInt64Field(value: inout [UInt64]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularSInt32Field(value: inout Int32) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularSInt32Field(value: inout Int32?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedSInt32Field(value: inout [Int32]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularSInt64Field(value: inout Int64) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularSInt64Field(value: inout Int64?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedSInt64Field(value: inout [Int64]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularFixed32Field(value: inout UInt32) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularFixed32Field(value: inout UInt32?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedFixed32Field(value: inout [UInt32]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularFixed64Field(value: inout UInt64) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularFixed64Field(value: inout UInt64?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedFixed64Field(value: inout [UInt64]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularSFixed32Field(value: inout Int32) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularSFixed32Field(value: inout Int32?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedSFixed32Field(value: inout [Int32]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularSFixed64Field(value: inout Int64) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularSFixed64Field(value: inout Int64?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedSFixed64Field(value: inout [Int64]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularBoolField(value: inout Bool) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularBoolField(value: inout Bool?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedBoolField(value: inout [Bool]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularStringField(value: inout String) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularStringField(value: inout String?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedStringField(value: inout [String]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularBytesField(value: inout Data) throws {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularBytesField(value: inout Data?) throws {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedBytesField(value: inout [Data]) throws {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularEnumField<E>(
        value: inout E
    ) throws where E: Enum, E.RawValue == Int {
        try setValue(&value, defaultValue: .init())
    }

    mutating func decodeSingularEnumField<E>(
        value: inout E?
    ) throws where E: Enum, E.RawValue == Int {
        try setValue(&value, defaultValue: nil)
    }

    mutating func decodeRepeatedEnumField<E>(
        value: inout [E]
    ) throws where E: Enum, E.RawValue == Int {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularMessageField<M>(
        value: inout M?
    ) throws where M: Message {
        try setMessageValue(&value)
    }

    mutating func decodeRepeatedMessageField<M>(
        value: inout [M]
    ) throws where M: Message {
        try setRepeatedValue(&value)
    }

    mutating func decodeSingularGroupField<G>(
        value: inout G?
    ) throws where G: Message {
        try setMessageValue(&value)
    }

    mutating func decodeRepeatedGroupField<G>(
        value: inout [G]
    ) throws where G: Message {
        try setRepeatedValue(&value)
    }

    mutating func decodeMapField<KeyType, ValueType>(
        fieldType: _ProtobufMap<KeyType, ValueType>.Type,
        value: inout _ProtobufMap<KeyType, ValueType>.BaseType
    ) throws where KeyType: MapKeyType, ValueType: MapValueType {
        try setMapValue(&value)
    }

    mutating func decodeMapField<KeyType, ValueType>(
        fieldType: _ProtobufEnumMap<KeyType, ValueType>.Type,
        value: inout _ProtobufEnumMap<KeyType, ValueType>.BaseType
    ) throws where KeyType: MapKeyType, ValueType: Enum, ValueType.RawValue == Int {
        try setMapValue(&value)
    }

    mutating func decodeMapField<KeyType, ValueType>(
        fieldType: _ProtobufMessageMap<KeyType, ValueType>.Type,
        value: inout _ProtobufMessageMap<KeyType, ValueType>.BaseType
    ) throws where KeyType: MapKeyType, ValueType: Hashable, ValueType: Message {
        try setMapValue(&value)
    }

    mutating func decodeExtensionField(
        values: inout ExtensionFieldValueSet,
        messageType: any Message.Type,
        fieldNumber: Int
    ) throws {
        preconditionFailure(
            "Internal Error: Path decoder should never decode an extension field"
        )
    }

}

extension Message {
    mutating func `set`(
        path: String,
        value: Any?,
        mergeOption: Google_Protobuf_FieldMask.MergeOptions
    ) throws {
        let _path = path.components(separatedBy: ".")
        var decoder = try PathDecoder<Self>(
            path: _path,
            value: value,
            mergeOption: mergeOption
        )
        try decodeMessage(decoder: &decoder)
    }
}