Skip to content
A small key-value data cache for iOS, macOS and tvOS, written in Swift.
Swift Ruby
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
Cachyr.xcodeproj Swift 5 fixes. Mar 26, 2019
Configs Swift 5 fixes. Mar 26, 2019
Docs Fixed typo. Dec 9, 2016
Sources Swift 5 fixes. Mar 26, 2019
Tests Storage size for disk cache. Mar 22, 2019
.gitignore Transferred cache source and test files from Yr app. Dec 8, 2016
Cachyr.podspec Podspec 1.3.0. Mar 26, 2019
LICENSE Transferred cache source and test files from Yr app. Dec 8, 2016
Package.swift Added SPM support (#7) Nov 4, 2019
README.md Updated readme with SPM info Jan 15, 2020

README.md

Cachyr

A typesafe key-value data cache for iOS, macOS, tvOS and watchOS written in Swift.

There already exists plenty of cache solutions, so why create one more? We had a few requirements where existing solutions fulfilled some of them but not all:

  • Written purely in Swift 3.
  • Type safety while still allowing any kind of data to be stored.
  • Disk and memory caching.
  • Easy way to populate cache when a lookup results in a cache miss.
  • Clean, single-purpose implementation. Do caching and nothing else.

Installation

CocoaPods

Add to Podfile:
pod 'Cachyr'

Then:
$ pod install

Swift Package Manager

The Swift Package Manager is a tool for managing the distribution of Swift code. It’s integrated with the Swift build system to automate the process of downloading, compiling, and linking dependencies.

To integrate Cachyr into your Xcode project using Xcode 11, specify it in File > Swift Packages > Add:

https://github.com/nrkno/yr-cachyr

Manual

Clone the repo somewhere suitable, like inside your project repo so Cachyr can be added as a subrepo, then drag Cachyr.xcodeproj into your project.

Alternatively build the framework and add it to your project.

Usage

let cache = DataCache()
let key = "foo"
let text = "bar"
cache.setValue(text, for: key)

// ... do important things ...

let cachedText: String? = cache.value(for: key)

// Or asynchronously
let cachedText = cache.value(for: key) { (value: String?) in
    // Do something with value
}

In this example the string bar is stored in the cache for the key foo. It is later retrieved as a string optional by explicitly declaring String? as the value type. Let's look at how generics enable easy data transformation.

let textAsData = cache.value(for: key) { (value: Data?) in
    print(value)
}

Now the exact same key is used to retrieve the data representation of the value. The cache stores everything as data, and by implementing the DataConvertable protocol for a type it is possible to convert the cached data to the return type you define when retrieving a value.

There are default DataConvertable implementations for Data, String, Int (all integer types), Float and Double.

For detailed usage examples take a look at Usage.md.

ToDo

This framework is production ready but there are still many possible improvements. Some known tasks are:

  • Better thread synchronization. The cache uses serial dispatch queues to handle concurrent access and memory/disk value synchronization. This makes the code easy to follow and reason about, but it is not as performant as a solution using the multiple reader single writer pattern. We tried using concurrent dispatch queues with dispatch barriers for cache updates, but it got messy and code readability suffered. In early development serial queues were the way to go, but there is room for improvement.
  • Limit for disk usage. The disk cache has no limit on how much data it stores.
  • Default DataConvertable support more common types.

Pull requests are very welcome.

You can’t perform that action at this time.