use crate::capability::CapClaim;
use crate::capability::CapGrant;
use crate::capability::ZomeCallCapGrant;
use crate::countersigning::CounterSigningSessionData;
use crate::header::ChainTopOrdering;
use holo_hash::hash_type;
use holo_hash::AgentPubKey;
use holo_hash::EntryHash;
use holo_hash::HashableContent;
use holo_hash::HashableContentBytes;
use holo_hash::HeaderHash;
use holochain_serialized_bytes::prelude::*;
mod app_entry_bytes;
mod error;
pub use app_entry_bytes::*;
pub use error::*;
pub const ENTRY_SIZE_LIMIT: usize = 16 * 1000 * 1000;
pub type CapGrantEntry = ZomeCallCapGrant;
pub type CapClaimEntry = CapClaim;
pub type EntryHashed = holo_hash::HoloHashed<Entry>;
impl From<EntryHashed> for Entry {
fn from(entry_hashed: EntryHashed) -> Self {
entry_hashed.into_content()
}
}
#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
pub struct GetOptions {
pub strategy: GetStrategy,
}
impl GetOptions {
pub fn latest() -> Self {
Self {
strategy: GetStrategy::Latest,
}
}
pub fn content() -> Self {
Self {
strategy: GetStrategy::Content,
}
}
}
impl Default for GetOptions {
fn default() -> Self {
Self::latest()
}
}
#[derive(PartialEq, Debug, Clone, Copy, Serialize, Deserialize)]
pub enum GetStrategy {
Latest,
Content,
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, SerializedBytes)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[serde(tag = "entry_type", content = "entry")]
pub enum Entry {
Agent(AgentPubKey),
App(AppEntryBytes),
CounterSign(Box<CounterSigningSessionData>, AppEntryBytes),
CapClaim(CapClaimEntry),
CapGrant(CapGrantEntry),
}
impl Entry {
pub fn as_cap_grant(&self) -> Option<CapGrant> {
match self {
Entry::Agent(key) => Some(CapGrant::ChainAuthor(key.clone())),
Entry::CapGrant(data) => Some(CapGrant::RemoteAgent(data.clone())),
_ => None,
}
}
pub fn as_cap_claim(&self) -> Option<&CapClaim> {
match self {
Entry::CapClaim(claim) => Some(claim),
_ => None,
}
}
pub fn app(sb: SerializedBytes) -> Result<Self, EntryError> {
Ok(Entry::App(AppEntryBytes::try_from(sb)?))
}
pub fn app_fancy<
E: Into<EntryError>,
SB: TryInto<SerializedBytes, Error = SerializedBytesError>,
>(
sb: SB,
) -> Result<Self, EntryError> {
Ok(Entry::App(AppEntryBytes::try_from(sb.try_into()?)?))
}
}
impl HashableContent for Entry {
type HashType = hash_type::Entry;
fn hash_type(&self) -> Self::HashType {
hash_type::Entry
}
fn hashable_content(&self) -> HashableContentBytes {
match self {
Entry::Agent(agent_pubkey) => {
HashableContentBytes::Prehashed39(
agent_pubkey
.clone()
.retype(holo_hash::hash_type::Entry)
.into_inner(),
)
}
entry => HashableContentBytes::Content(
entry
.try_into()
.expect("Could not serialize HashableContent"),
),
}
}
}
#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, SerializedBytes)]
pub struct CreateInput {
pub entry_def_id: crate::entry_def::EntryDefId,
pub entry: crate::entry::Entry,
pub chain_top_ordering: ChainTopOrdering,
}
impl CreateInput {
pub fn new(
entry_def_id: crate::entry_def::EntryDefId,
entry: crate::entry::Entry,
chain_top_ordering: ChainTopOrdering,
) -> Self {
Self {
entry_def_id,
entry,
chain_top_ordering,
}
}
pub fn into_entry(self) -> Entry {
self.entry
}
pub fn chain_top_ordering(&self) -> &ChainTopOrdering {
&self.chain_top_ordering
}
}
impl AsRef<crate::Entry> for CreateInput {
fn as_ref(&self) -> &crate::Entry {
&self.entry
}
}
impl AsRef<crate::EntryDefId> for CreateInput {
fn as_ref(&self) -> &crate::EntryDefId {
&self.entry_def_id
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct GetInput {
pub any_dht_hash: holo_hash::AnyDhtHash,
pub get_options: crate::entry::GetOptions,
}
impl GetInput {
pub fn new(any_dht_hash: holo_hash::AnyDhtHash, get_options: crate::entry::GetOptions) -> Self {
Self {
any_dht_hash,
get_options,
}
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct MustGetValidElementInput(HeaderHash);
impl MustGetValidElementInput {
pub fn new(header_hash: HeaderHash) -> Self {
Self(header_hash)
}
pub fn into_inner(self) -> HeaderHash {
self.0
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct MustGetEntryInput(EntryHash);
impl MustGetEntryInput {
pub fn new(entry_hash: EntryHash) -> Self {
Self(entry_hash)
}
pub fn into_inner(self) -> EntryHash {
self.0
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct MustGetHeaderInput(HeaderHash);
impl MustGetHeaderInput {
pub fn new(header_hash: HeaderHash) -> Self {
Self(header_hash)
}
pub fn into_inner(self) -> HeaderHash {
self.0
}
}
#[derive(PartialEq, Debug, Deserialize, Serialize, Clone)]
pub struct UpdateInput {
pub original_header_address: holo_hash::HeaderHash,
pub create_input: CreateInput,
}
impl UpdateInput {
pub fn new(original_header_address: holo_hash::HeaderHash, create_input: CreateInput) -> Self {
Self {
original_header_address,
create_input,
}
}
}
#[derive(PartialEq, Debug, Deserialize, Serialize, Clone)]
pub struct DeleteInput {
pub deletes_header_address: holo_hash::HeaderHash,
pub chain_top_ordering: ChainTopOrdering,
}
impl DeleteInput {
pub fn new(
deletes_header_address: holo_hash::HeaderHash,
chain_top_ordering: ChainTopOrdering,
) -> Self {
Self {
deletes_header_address,
chain_top_ordering,
}
}
}