Swift: Swiftプロトコル：インターフェース定��、プロトコル継承とデリゲートパターン

class CreditCardPayment {
    func processCardPayment(amount: Double, cardNumber: String) -> Bool {
        // Credit card processing
        return true
    }
}
class PayPalPayment {
    func payWithPayPal(amount: Double, email: String) -> Bool {
        // PayPal processing
        return true
    }
}
class WeChatPayment {
    func wechatPay(amount: Double, code: String) -> Bool {
        // WeChat Pay processing
        return true
    }
}

protocol PaymentMethod {
    func pay(amount: Double) -> Bool
}
struct CreditCard: PaymentMethod {
    let cardNumber: String
    func pay(amount: Double) -> Bool { /* Process */ true }
}
struct PayPal: PaymentMethod {
    let email: String
    func pay(amount: Double) -> Bool { /* Process */ true }
}
// Unified handling
func checkout(amount: Double, using method: PaymentMethod) {
    method.pay(amount: amount)
}

// ============================================
// Defining and conforming to a protocol
// ============================================
// 1. Define the protocol
protocol Describable {
    var description: String { get }
    func summarize() -> String
}
// 2. Struct conforming to the protocol
struct Book: Describable {
    let title: String
    let author: String
    var description: String {
        return "\"\(title)\" by \(author)"
    }
    func summarize() -> String {
        return "Book: \(description)"
    }
}
// 3. Class conforming to the protocol
class Movie: Describable {
    let title: String
    let director: String
    init(title: String, director: String) {
        self.title = title
        self.director = director
    }
    var description: String {
        return "\(title) (directed by \(director))"
    }
    func summarize() -> String {
        return "Movie: \(description)"
    }
}
let book = Book(title: "1984", author: "George Orwell")
let movie = Movie(title: "Inception", director: "Christopher Nolan")
print(book.summarize())
print(movie.summarize())

// ============================================
// Protocol inheritance — a refundable payment protocol
// ============================================
protocol Payable {
    var amount: Double { get }
    func process() -> Bool
}
protocol Refundable: Payable {  // Inherits Payable
    func refund() -> Bool
}
// CreditCard implements refundable payment
struct CreditCard: Refundable {
    let amount: Double
    let cardNumber: String
    func process() -> Bool {
        print("Processing $\(amount) on card \(cardNumber)")
        return true
    }
    func refund() -> Bool {
        print("Refunding $\(amount) to card \(cardNumber)")
        return true
    }
}
// GiftCard can pay but not refund
struct GiftCard: Payable {
    let amount: Double
    let code: String
    func process() -> Bool {
        print("Processing $\(amount) with gift card \(code)")
        return true
    }
}
let payments: [Payable] = [
    CreditCard(amount: 100, cardNumber: "1234"),
    GiftCard(amount: 50, code: "GIFT-001")
]
for payment in payments {
    payment.process()
    // Check if also Refundable
    if let refundable = payment as? Refundable {
        print("  This payment can be refunded")
    }
}

protocol Identifiable {
    var id: String { get }
}
protocol Loggable {
    func log()
}
// Type must conform to both Identifiable and Loggable
func saveItem(_ item: Identifiable & Loggable) {
    print("Saving item \(item.id)")
    item.log()
}
struct User: Identifiable, Loggable {
    let id: String
    func log() { print("User logged: \(id)") }
}
let user = User(id: "U-001")
saveItem(user)

// ============================================
// Adding default implementations to protocols via extension
// ============================================
protocol Greetable {
    var name: String { get }
    func greet() -> String
}
// Default implementation
extension Greetable {
    func greet() -> String {
        return "Hello, \(name)!"
    }
}
// Person uses the default implementation
struct Person: Greetable {
    let name: String
    // No need to implement greet() — uses the default version
}
// Robot provides a custom implementation
struct Robot: Greetable {
    let name: String
    func greet() -> String {
        return "Beep boop, I am \(name)"
    }
}
print(Person(name: "Alice").greet())
print(Robot(name: "R2-D2").greet())

// ============================================
// Delegate pattern: Download manager
// ============================================
// 1. Define the delegate protocol
protocol DownloadDelegate: AnyObject {
    func downloadDidStart(_ url: String)
    func downloadDidProgress(_ url: String, percent: Double)
    func downloadDidComplete(_ url: String, data: String)
    func downloadDidFail(_ url: String, error: String)
}
// 2. Download manager — delegates events to an external handler
class DownloadManager {
    weak var delegate: DownloadDelegate?
    func download(from url: String) {
        delegate?.downloadDidStart(url)
        // Simulate download progress
        for i in 1...5 {
            let percent = Double(i) / 5.0 * 100
            delegate?.downloadDidProgress(url, percent: percent)
        }
        // Simulate completion
        delegate?.downloadDidComplete(url, data: "Downloaded content from \(url)")
    }
}
// 3. View controller — acting as the delegate
class ViewController: DownloadDelegate {
    func downloadDidStart(_ url: String) {
        print("[UI] Download started: \(url)")
    }
    func downloadDidProgress(_ url: String, percent: Double) {
        print("[UI] \(url): \(Int(percent))%")
    }
    func downloadDidComplete(_ url: String, data: String) {
        print("[UI] Download complete: \(data.prefix(20))...")
    }
    func downloadDidFail(_ url: String, error: String) {
        print("[UI] Download failed: \(error)")
    }
}
let manager = DownloadManager()
let ui = ViewController()
manager.delegate = ui  // Set the delegate
manager.download(from: "https://example.com/file.zip")

// ============================================
// Complete example: Data validation system
// Features: Protocol + protocol inheritance + extension defaults + delegate pattern
// ============================================
import Foundation
// 1. Validation protocol hierarchy
protocol Validatable {
    var value: Any { get }
    func validate() -> Bool
}
// Validation with detailed error reporting
protocol DetailedValidatable: Validatable {
    func errorMessage() -> String
}
// Default implementation
extension Validatable {
    func validate() -> Bool { return true }
}
// 2. Concrete validators
struct EmailValidator: DetailedValidatable {
    let value: Any
    func validate() -> Bool {
        guard let email = value as? String else { return false }
        return email.contains("@") && email.contains(".")
    }
    func errorMessage() -> String {
        return "Invalid email format"
    }
}
struct AgeValidator: DetailedValidatable {
    let value: Any
    func validate() -> Bool {
        guard let age = value as? Int else { return false }
        return age >= 18 && age <= 120
    }
    func errorMessage() -> String {
        return "Age must be between 18 and 120"
    }
}
struct NonEmptyValidator: Validatable {
    let value: Any
    // Uses default validate() which returns true, but we customize it
    func validate() -> Bool {
        guard let text = value as? String else { return false }
        return !text.isEmpty
    }
}
// 3. Delegate — validation result handler
protocol ValidationDelegate: AnyObject {
    func validationDidSucceed(for field: String)
    func validationDidFail(for field: String, error: String)
}
// 4. Validation manager
class ValidationManager {
    weak var delegate: ValidationDelegate?
    private var validators: [(field: String, validator: Validatable)] = []
    func addValidator(for field: String, validator: Validatable) {
        validators.append((field, validator))
    }
    func runAll() -> Bool {
        var allValid = true
        for (field, validator) in validators {
            if validator.validate() {
                delegate?.validationDidSucceed(for: field)
            } else {
                allValid = false
                let error = (validator as? DetailedValidatable)?.errorMessage() ?? "Validation failed"
                delegate?.validationDidFail(for: field, error: error)
            }
        }
        return allValid
    }
}
// 5. Usage
class FormController: ValidationDelegate {
    func validationDidSucceed(for field: String) {
        print("[OK] \(field) is valid")
    }
    func validationDidFail(for field: String, error: String) {
        print("[FAIL] \(field): \(error)")
    }
}
let manager = ValidationManager()
manager.delegate = FormController()
manager.addValidator(for: "email", validator: EmailValidator(value: "alice@example.com"))
manager.addValidator(for: "age", validator: AgeValidator(value: 25))
manager.addValidator(for: "name", validator: NonEmptyValidator(value: "Alice"))
let allValid = manager.runAll()
print("Form valid: \(allValid)")