Buffer alternatives and similar libraries
Based on the "Data Structures / Algorithms" category.
Alternatively, view Buffer alternatives based on common mentions on social networks and blogs.
-
KeyPathKit
KeyPathKit is a library that provides the standard functions to manipulate data along with a call-syntax that relies on typed keypaths to make the call sites as short and clean as possible. -
BinaryKit
💾🔍🧮 BinaryKit helps you to break down binary data into bits and bytes, easily access specific parts and write data to binary. -
RandMyMod
RandMyMod base on your own struct or class create one or a set of instance, which the variable's value in the instance is automatic randomized. -
OneWaySynchronizer
The simplest abstraction to synchronize local data with remote source. For iOS, wirtten in swift.
CodeRabbit: AI Code Reviews for Developers
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of Buffer or a related project?
README
Buffer [](#) [](#)
Swift μ-framework for efficient array diffs, collection observation and data source implementation.
Installation
cd {PROJECT_ROOT_DIRECTORY}
curl "https://raw.githubusercontent.com/alexdrone/Buffer/master/bin/dist.zip" > dist.zip && unzip dist.zip && rm dist.zip;
Drag Buffer.framework
in your project and add it as an embedded binary.
If you use xcodegen add the framework to your project.yml like so:
targets:
YOUR_APP_TARGET:
...
dependencies:
- framework: PATH/TO/YOUR/DEPS/Buffer.framework
Installation with CocoaPods/Carthage (deprecated)
If you are using CocoaPods:
Add the following to your Podfile:
pod 'Buffer'
If you are using Carthage:
To install Carthage, run (using Homebrew):
$ brew update
$ brew install carthage
Then add the following line to your Cartfile
:
github "alexdrone/Buffer" "master"
Getting started
Buffer is designed to be very granular and has APIs with very different degrees of abstraction.
Managing a collection with Buffer
You can initialize and use Buffer in the following way.
import Buffer
class MyClass: BufferDelegate {
lazy var buffer: Buffer<Foo> = {
// The `sort` and the `filter` closure are optional - they are a convenient way to map the src array.
let buffer = Buffer(initialArray: self.elements, sort: { $0.bar > $1.bar }, filter: { $0.isBaz })
buffer.delegate = self
}()
var elements: [Foo] = [Foo]() {
didSet {
// When the elements are changed the buffer object will compute the difference and trigger
// the invocation of the delegate methods.
// The `synchronous` and `completion` arguments are optional.
self.buffer.update(with: newValues, synchronous: false, completion: nil)
}
}
//These methods will be called when the buffer has changedd.
public func buffer(willChangeContent buffer: BufferType) {
//e.g. self.tableView?.beginUpdates()
}
public func buffer(didDeleteElementAtIndices buffer: BufferType, indices: [UInt]) {
//e.g. Remove rows from a tableview
}
public func buffer(didInsertElementsAtIndices buffer: BufferType, indices: [UInt]) {
}
public func buffer(didChangeContent buffer: BufferType) {
}
public func buffer(didChangeElementAtIndex buffer: BufferType, index: UInt) {
}
public func buffer(didMoveElement buffer: BufferType, from: UInt, to: UInt) {
}
public func buffer(didChangeAllContent buffer: BufferType) {
}
}
Built-in UITableView and UICollectionView adapter
One of the main use cases for Buffer is probably to apply changes to a TableView or a CollectionView.
Buffer provides 2 adapter classes that implement the BufferDelegate
protocol and automatically perform the required
changes on the target tableview/collectionview when required.
import Buffer
class MyClass: UITableViewController {
lazy var buffer: Buffer<Foo> = {
// The `sort` and the `filter` closure are optional - they are convenient way to map the src array.
let buffer = Buffer(initialArray: self.elements, sort: { $0.bar > $1.bar }, filter: { $0.isBaz })
buffer.delegate = self
}()
var elements: [Foo] = [Foo]() {
didSet {
// When the elements are changed the buffer object will compute the difference and trigger
// the invocation of the delegate methods.
// The `synchronous` and `completion` arguments are optional.
self.buffer.update(with: newValues, synchronous: false, completion: nil)
}
}
let adapter: TableViewDiffAdapter<Foo>!
init() {
super.init()
self.adapter = TableViewDiffAdapter(buffer: self.buffer, view: self.tableView)
// Additionaly you can let the adapter be the datasource for your table view by passing a cell
// configuration closure to the adpater.
adapter.useAsDataSource { (tableView, object, indexPath) -> UITableViewCell in
let cell = tableView.dequeueReusableCellWithIdentifier("MyCell")
cell?.textLabel?.text = object.foo
return cell
}
}
}
Component-Oriented TableView
Another convenient way to use Buffer is through the Buffer.TableView
class.
This abstraction allows for the tableView to reconfigure itself when its state (the elements) change.
import Buffer
class ViewController: UIViewController {
lazy var tableView: TableView<FooModel> = {
let tableView = TableView<FooModel>()
return tableView
}()
lazy var elements: [ListItem<FooModel>] = {
var elements = [ListItem<FooModel>]()
for _ in 0...100 {
// AnyListItem wraps the data and the configuration for every row in the tableview.
let item = ListItem(type: UITableViewCell.self,
container: self.tableView,
model: FooModel(text: "Foo"))) {
cell, model in
cell.textLabel?.text = model.text
}
elements.append(item)
}
return elements
}()
override func viewDidLayoutSubviews() {
self.tableView.frame = self.view.bounds
}
override func viewDidLoad() {
super.viewDidLoad()
self.view.addSubview(self.tableView)
self.tableView.elements = self.elements
}
}
Check the demo out to learn more about Buffer.
Credits
- Diff algorithm from IGListKit/IGListDiff
*Note that all licence references and agreements mentioned in the Buffer README section above
are relevant to that project's source code only.