Протоколы Swift: мощный инструмент типобезопасной архитектуры

protocol Identifiable {
var id: String { get }
func identify() -> String
}

struct User: Identifiable {
var id: String
var name: String

func identify() -> String {
return "User ID: \(id), Name: \(name)"
}
}

class Product: Identifiable, Equatable, Hashable {
var id: String
var price: Double

init(id: String, price: Double) {
self.id = id
self.price = price
}

func identify() -> String {
return "Product ID: \(id), Price: \(price)"
}

static func == (lhs: Product, rhs: Product) -> Bool {
return lhs.id == rhs.id
}

func hash(into hasher: inout Hasher) {
hasher.combine(id)
}
}

protocol DataProvider {
var isReady: Bool { get }
var lastUpdateTimestamp: TimeInterval { get }

func fetchData() -> Data?
func update(completion: @escaping (Bool) -> Void)

init(source: String)

subscript(index: Int) -> String { get }

static var supportedFormats: [String] { get }
static func register(provider: DataProvider)
}

protocol TextRepresentable {
var textDescription: String { get }
}

extension TextRepresentable {
func printDescription() {
print(textDescription)
}
}

struct Book: TextRepresentable {
var title: String
var author: String

var textDescription: String {
return "\(title) by \(author)"
}
}

let book = Book(title: "Swift Programming", author: "Apple Inc.")
book.printDescription() // Выводит: "Swift Programming by Apple Inc."

protocol Togglable {
mutating func toggle()
}

extension Togglable {
mutating func toggle() {
// Реализация по умолчанию
print("Default toggle implementation")
}
}

struct Switch: Togglable {
var isOn: Bool = false

mutating func toggle() {
isOn = !isOn
print("Switch is now \(isOn ? "on" : "off")")
}
}

var lightSwitch = Switch()
lightSwitch.toggle() // Использует собственную реализацию

struct DefaultSwitch: Togglable {
// Не реализует toggle(), поэтому использует реализацию из расширения
}

var defaultSwitch = DefaultSwitch()
defaultSwitch.toggle() // Использует реализацию по умолчанию

protocol Named {
var name: String { get }
}

protocol Aged {
var age: Int { get }
}

protocol Person: Named, Aged {
var profession: String { get }
}

struct Employee: Person {
var name: String
var age: Int
var profession: String
}

// Расширение для коллекций, содержащих элементы типа Equatable
extension Collection where Element: Equatable {
func containsDuplicates() -> Bool {
for (index, element) in self.enumerated() {
if self.dropFirst(index + 1).contains(element) {
return true
}
}
return false
}
}

let uniqueNumbers = [1, 2, 3, 4, 5]
let duplicateNumbers = [1, 2, 3, 2, 5]

print(uniqueNumbers.containsDuplicates()) // false
print(duplicateNumbers.containsDuplicates()) // true

protocol Container {
associatedtype Item
mutating func add(_ item: Item)
var count: Int { get }
subscript(i: Int) -> Item { get }
}

struct IntStack: Container {
// Конкретизируем ассоциированный тип как Int
typealias Item = Int

var items = [Int]()

mutating func add(_ item: Int) {
items.append(item)
}

var count: Int {
return items.count
}

subscript(i: Int) -> Int {
return items[i]
}
}

struct Queue<T>: Container {
// Здесь Item автоматически определяется как T
var items = [T]()

mutating func add(_ item: T) {
items.append(item)
}

var count: Int {
return items.count
}

subscript(i: Int) -> T {
return items[i]
}
}

protocol DataFetching {
associatedtype DataType
associatedtype ErrorType: Error

func fetchData() async throws -> DataType
func cancel()
var isFetching: Bool { get }
}

// Использование через generic constraints
func process<T: DataFetching>(fetcher: T) where T.DataType == [String] {
// Обработка fetcher
}

// Type erasure для абстрактного протокола
struct AnyDataFetcher<Data, Err: Error>: DataFetching {
typealias DataType = Data
typealias ErrorType = Err

private let _fetchData: () async throws -> Data
private let _cancel: () -> Void
private let _isFetching: () -> Bool

var isFetching: Bool { _isFetching() }

init<F: DataFetching>(_ fetcher: F) where F.DataType == Data, F.ErrorType == Err {
_fetchData = fetcher.fetchData
_cancel = fetcher.cancel
_isFetching = { fetcher.isFetching }
}

func fetchData() async throws -> Data {
return try await _fetchData()
}

func cancel() {
_cancel()
}
}

// Теперь можно использовать AnyDataFetcher как конкретный тип
let fetcher: AnyDataFetcher<[String], URLError> = AnyDataFetcher(NetworkFetcher())

protocol Loggable {
func log(message: String)
var logLevel: Int { get set }
}

class ConsoleLogger: Loggable {
var logLevel: Int = 1

func log(message: String) {
if logLevel > 0 {
print("[\(Date())] \(message)")
}
}
}

// Можно использовать напрямую как тип
func configureLogging(logger: Loggable) {
logger.logLevel = 2
logger.log(message: "Logging configured")
}

let logger = ConsoleLogger()
configureLogging(logger: logger)

protocol Theme {
var backgroundColor: UIColor { get }
var textColor: UIColor { get }
var accentColor: UIColor { get }
var fontFamily: String { get }
}

struct DarkTheme: Theme {
let backgroundColor = UIColor.black
let textColor = UIColor.white
let accentColor = UIColor.blue
let fontFamily = "Helvetica"
}

struct LightTheme: Theme {
let backgroundColor = UIColor.white
let textColor = UIColor.black
let accentColor = UIColor.red
let fontFamily = "Arial"
}

class ThemableView: UIView {
var theme: Theme {
didSet {
applyTheme()
}
}

init(theme: Theme) {
self.theme = theme
super.init(frame: .zero)
applyTheme()
}

required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}

private func applyTheme() {
backgroundColor = theme.backgroundColor
// Применение других свойств темы
}
}

protocol Repository {
associatedtype Entity
associatedtype ID

func fetch(withID id: ID) async throws -> Entity?
func fetchAll() async throws -> [Entity]
func save(_ entity: Entity) async throws
func delete(withID id: ID) async throws
}

class UserRepository: Repository {
typealias Entity = User
typealias ID = UUID

private var storage: [UUID: User] = [:]

func fetch(withID id: ID) async throws -> User? {
return storage[id]
}

func fetchAll() async throws -> [User] {
return Array(storage.values)
}

func save(_ entity: User) async throws {
storage[entity.id] = entity
}

func delete(withID id: ID) async throws {
storage.removeValue(forKey: id)
}
}

// Type Erasure для Repository
struct AnyRepository<E, I>: Repository {
typealias Entity = E
typealias ID = I

private let _fetch: (I) async throws -> E?
private let _fetchAll: () async throws -> [E]
private let _save: (E) async throws -> Void
private let _delete: (I) async throws -> Void

init<R: Repository>(_ repository: R) where R.Entity == E, R.ID == I {
_fetch = repository.fetch
_fetchAll = repository.fetchAll
_save = repository.save
_delete = repository.delete
}

func fetch(withID id: I) async throws -> E? {
return try await _fetch(id)
}

func fetchAll() async throws -> [E] {
return try await _fetchAll()
}

func save(_ entity: E) async throws {
try await _save(entity)
}

func delete(withID id: I) async throws {
try await _delete(id)
}
}

protocol NetworkService {
func fetchData(from url: URL) async throws -> Data
}

class RealNetworkService: NetworkService {
func fetchData(from url: URL) async throws -> Data {
let (data, _) = try await URLSession.shared.data(from: url)
return data
}
}

class MockNetworkService: NetworkService {
var stubbedData: Data?
var error: Error?

func fetchData(from url: URL) async throws -> Data {
if let error = error {
throw error
}
return stubbedData ?? Data()
}
}

class UserViewModel {
private let networkService: NetworkService

init(networkService: NetworkService) {
self.networkService = networkService
}

func fetchUserData() async throws -> User {
let url = URL(string: "https://api.example.com/user")!
let data = try await networkService.fetchData(from: url)
return try JSONDecoder().decode(User.self, from: data)
}
}

// Использование для продакшена
let realService = RealNetworkService()
let viewModel = UserViewModel(networkService: realService)

// Использование для тестирования
let mockService = MockNetworkService()
mockService.stubbedData = """
{
"id": "1234",
"name": "John Doe",
"email": "john@example.com"
}
""".data(using: .utf8)

let testViewModel = UserViewModel(networkService: mockService)

// Протокол для ViewModel
protocol UserDetailsViewModel {
var username: String { get }
var email: String { get }
var followers: Int { get }
var isLoading: Bool { get }

func loadUserDetails() async
func followUser() async
}

// Конкретная реализация ViewModel
class RealUserDetailsViewModel: UserDetailsViewModel {
private let userService: UserService
private var user: User?

private(set) var isLoading: Bool = false

var username: String {
user?.username ?? "Unknown"
}

var email: String {
user?.email ?? "No email"
}

var followers: Int {
user?.followers ?? 0
}

init(userService: UserService) {
self.userService = userService
}

func loadUserDetails() async {
isLoading = true
do {
user = try await userService.fetchCurrentUser()
} catch {
print("Error: \(error)")
}
isLoading = false
}

func followUser() async {
guard let userId = user?.id else { return }
try? await userService.followUser(userId)
}
}

// View, использующая ViewModel через протокол
class UserDetailsViewController: UIViewController {
private let viewModel: UserDetailsViewModel

// UI элементы
private let usernameLabel = UILabel()
private let emailLabel = UILabel()
private let followersLabel = UILabel()
private let followButton = UIButton()
private let loadingIndicator = UIActivityIndicatorView()

init(viewModel: UserDetailsViewModel) {
self.viewModel = viewModel
super.init(nibName: nil, bundle: nil)
}

required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}

override func viewDidLoad() {
super.viewDidLoad()
setupUI()

Task {
await loadData()
}
}

private func loadData() async {
updateLoadingState()
await viewModel.loadUserDetails()
updateUI()
updateLoadingState()
}

private func updateUI() {
usernameLabel.text = viewModel.username
emailLabel.text = viewModel.email
followersLabel.text = "\(viewModel.followers) followers"
}

private func updateLoadingState() {
if viewModel.isLoading {
loadingIndicator.startAnimating()
} else {
loadingIndicator.stopAnimating()
}
}

@objc private func followButtonTapped() {
Task {
await viewModel.followUser()
await loadData()
}
}

// Настройка UI элементов...
private func setupUI() {
// ...
}
}

protocol Coordinator: AnyObject {
var childCoordinators: [Coordinator] { get set }
var navigationController: UINavigationController { get set }

func start()
}

protocol AuthCoordinator: Coordinator {
func showLogin()
func showRegistration()
func didFinishAuth()
}

class MainCoordinator: Coordinator {
var childCoordinators: [Coordinator] = []
var navigationController: UINavigationController

private var authCompletionHandler: (() -> Void)?

init(navigationController: UINavigationController) {
self.navigationController = navigationController
}

func start() {
showDashboard()
}

func showDashboard() {
let vm = DashboardViewModel()
vm.coordinator = self
let vc = DashboardViewController(viewModel: vm)
navigationController.setViewControllers([vc], animated: false)
}

func showAuth(completion: @escaping () -> Void) {
authCompletionHandler = completion

let authCoordinator = AppAuthCoordinator(navigationController: navigationController)
authCoordinator.delegate = self
childCoordinators.append(authCoordinator)
authCoordinator.start()
}

func showSettings() {
let vm = SettingsViewModel()
vm.coordinator = self
let vc = SettingsViewController(viewModel: vm)
navigationController.pushViewController(vc, animated: true)
}
}

extension MainCoordinator: AuthCoordinatorDelegate {
func authCoordinatorDidFinish(_ coordinator: AuthCoordinator) {
navigationController.dismiss(animated: true)
childCoordinators.removeAll { $0 === coordinator }
authCompletionHandler?()
}
}

protocol AuthCoordinatorDelegate: AnyObject {
func authCoordinatorDidFinish(_ coordinator: AuthCoordinator)
}

class AppAuthCoordinator: AuthCoordinator {
var childCoordinators: [Coordinator] = []
var navigationController: UINavigationController
weak var delegate: AuthCoordinatorDelegate?

init(navigationController: UINavigationController) {
self.navigationController = navigationController
}

func start() {
showLogin()
}

func showLogin() {
let vm = LoginViewModel()
vm.coordinator = self
let vc = LoginViewController(viewModel: vm)
navigationController.pushViewController(vc, animated: true)
}

func showRegistration() {
let vm = RegistrationViewModel()
vm.coordinator = self
let vc = RegistrationViewController(viewModel: vm)
navigationController.pushViewController(vc, animated: true)
}

func didFinishAuth() {
delegate?.authCoordinatorDidFinish(self)
}
}

protocol UserRepository {
func fetchUser(id: String) async throws -> User
func fetchAllUsers() async throws -> [User]
func save(user: User) async throws
func delete(id: String) async throws
}

class APIUserRepository: UserRepository {
private let networkService: NetworkService

init(networkService: NetworkService) {
self.networkService = networkService
}

func fetchUser(id: String) async throws -> User {
let url = URL(string: "https://api.example.com/users/\(id)")!
let data = try await networkService.fetchData(from: url)
return try JSONDecoder().decode(User.self, from: data)
}

func fetchAllUsers() async throws -> [User] {
let url = URL(string: "https://api.example.com/users")!
let data = try await networkService.fetchData(from: url)
return try JSONDecoder().decode([User].self, from: data)
}

func save(user: User) async throws {
// Реализация сохранения пользователя через API
}

func delete(id: String) async throws {
// Реализация удаления пользователя через API
}
}

class LocalUserRepository: UserRepository {
private let coreDataStack: CoreDataStack

init(coreDataStack: CoreDataStack) {
self.coreDataStack = coreDataStack
}

func fetchUser(id: String) async throws -> User {
// Реализация получения пользователя из CoreData
// ...
return User(id: id, username: "test", email: "test@example.com")
}

// Другие методы
// ...
}

// Использование в приложении
class UserService {
private let repository: UserRepository

init(repository: UserRepository) {
self.repository = repository
}

func getUser(id: String) async throws -> User {
return try await repository.fetchUser(id: id)
}

// Другие методы...
}