defprotocol SData.Page do
@moduledoc"""
Protocol to be implemented by objects that are used as data pages
in a pagestore and that may reference other data pages by their hash.
"""
@fallback_to_any true
@doc"""
Get hashes of all pages referenced by this page.
"""
def refs(page)
end
defimpl SData.Page, for: Any do
def refs(_page), do: []
end
defprotocol SData.PageStore do
@moduledoc"""
Protocol to be implemented for page stores to allow their
manipulation.
This protocol may also be implemented by store proxies that track
operations and implement different synchronization or caching mechanisms.
A page store is an object that stores data pages (arbitrary Erlang terms) and
identifies them by their hash. Dependencies may exist between pages, in which
case they form a Merkle DAG.
"""
@doc"""
Put a page. Argument is the content of the page, returns the
hash that the store has associated to it.
Returns {hash, store}
"""
def put(store, page)
@doc"""
Get a page referenced by its hash.
Returns page
"""
def get(store, hash)
@doc"""
Copy to the store a page and all its references from the other store.
In the case of pages on the network in a distributed store, this may
be lazy.
Returns store
"""
def copy(store, other_store, hash)
@doc"""
Free a page referenced by its hash, marking it as no longer needed.
Returns store
"""
def free(store, hash)
end
defmodule SData.LocalStore do
@moduledoc"""
A page store that saves all pages locally in RAM. The store is basically a dictionnary
of hash to term mappings, which is mutated by put operations.
"""
defstruct [:pages]
@doc"""
Create empty LocalStore.
"""
def new() do
%SData.LocalStore{ pages: %{} }
end
end
defimpl SData.PageStore, for: SData.LocalStore do
def put(store, page) do
hash = SData.term_hash page
store = %{ store | pages: Map.put(store.pages, hash, page) }
{ hash, store }
end
def get(store, hash) do
store.pages[hash]
end
def copy(store, other_store, hash) do
page = SData.PageStore.get(other_store, hash)
refs = SData.Page.refs(page)
store = Enum.reduce(refs, store, fn x, acc -> copy(acc, other_store, x) end)
%{ store | pages: Map.put(store.pages, hash, page) }
end
def free(store, hash) do
%{ store | pages: Map.delete(store.pages, hash) }
end
end
