use crate::action::ZomeIndex;
use crate::zome::ZomeName;
use crate::EntryDefIndex;
use crate::EntryDefs;
use crate::FunctionName;
use crate::LinkType;
use holo_hash::DnaHash;
use holochain_serialized_bytes::prelude::*;
#[cfg(test)]
mod test;
#[allow(missing_docs)]
#[derive(Clone, Debug, Serialize, Deserialize, SerializedBytes, PartialEq)]
pub struct ZomeInfo {
pub name: ZomeName,
pub id: ZomeIndex,
pub properties: SerializedBytes,
pub entry_defs: EntryDefs,
pub extern_fns: Vec<FunctionName>,
pub zome_types: ScopedZomeTypesSet,
}
impl ZomeInfo {
pub fn new(
name: ZomeName,
id: ZomeIndex,
properties: SerializedBytes,
entry_defs: EntryDefs,
extern_fns: Vec<FunctionName>,
zome_types: ScopedZomeTypesSet,
) -> Self {
Self {
name,
id,
properties,
entry_defs,
extern_fns,
zome_types,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct DnaInfo {
pub name: String,
pub hash: DnaHash,
pub properties: SerializedBytes,
pub zome_names: Vec<ZomeName>,
}
#[derive(Clone, Debug, Serialize, Deserialize, SerializedBytes, PartialEq, Default)]
pub struct ScopedZomeTypesSet {
pub entries: ScopedZomeTypes<EntryDefIndex>,
pub links: ScopedZomeTypes<LinkType>,
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct ScopedZomeTypes<T>(pub Vec<(ZomeIndex, Vec<T>)>);
impl<T> Default for ScopedZomeTypes<T> {
fn default() -> Self {
Self(Default::default())
}
}
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ZomeTypesKey<T>
where
T: U8Index + Copy,
{
pub zome_index: ZomeDependencyIndex,
pub type_index: T,
}
pub type ZomeEntryTypesKey = ZomeTypesKey<EntryDefIndex>;
pub type ZomeLinkTypesKey = ZomeTypesKey<LinkType>;
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ZomeDependencyIndex(pub u8);
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ScopedZomeType<T> {
pub zome_index: ZomeIndex,
pub zome_type: T,
}
pub type ScopedEntryDefIndex = ScopedZomeType<EntryDefIndex>;
pub type ScopedLinkType = ScopedZomeType<LinkType>;
impl<T> ScopedZomeTypes<T>
where
T: U8Index + Copy,
{
pub fn get<K>(&self, key: K) -> Option<ScopedZomeType<T>>
where
K: Into<ZomeTypesKey<T>>,
{
let key = key.into();
self.0
.get(key.zome_index.index())
.and_then(|(zome_index, types)| {
types
.get(key.type_index.index())
.copied()
.map(|zome_type| ScopedZomeType {
zome_index: *zome_index,
zome_type,
})
})
}
pub fn find<I, K>(&self, iter: I, scoped_type: ScopedZomeType<T>) -> Option<I::Item>
where
I: IntoIterator<Item = K>,
K: Into<ZomeTypesKey<T>> + Copy,
T: PartialEq,
{
iter.into_iter()
.find_map(|key| (self.get(key)? == scoped_type).then_some(key))
}
pub fn find_key(&self, scoped_type: ScopedZomeType<T>) -> Option<ZomeTypesKey<T>>
where
T: PartialEq,
T: From<u8>,
{
self.0
.iter()
.position(|(zome_index, _)| *zome_index == scoped_type.zome_index)
.and_then(|zome_index| {
self.0[zome_index]
.1
.iter()
.position(|zome_type| *zome_type == scoped_type.zome_type)
.and_then(|type_index| {
Some(ZomeTypesKey {
zome_index: u8::try_from(zome_index).ok()?.into(),
type_index: u8::try_from(type_index).ok()?.into(),
})
})
})
}
pub fn dependencies(&self) -> impl Iterator<Item = ZomeIndex> + '_ {
self.0.iter().map(|(zome_index, _)| *zome_index)
}
}
impl From<EntryDefIndex> for ZomeEntryTypesKey {
fn from(type_index: EntryDefIndex) -> Self {
Self {
zome_index: 0.into(),
type_index,
}
}
}
impl From<LinkType> for ZomeLinkTypesKey {
fn from(type_index: LinkType) -> Self {
Self {
zome_index: 0.into(),
type_index,
}
}
}
#[doc(hidden)]
pub trait EnumLen {
const ENUM_LEN: u8;
}
#[doc(hidden)]
pub trait EnumVariantLen<const V: u8> {
const ENUM_VARIANT_START: u8;
const ENUM_VARIANT_INNER_LEN: u8;
const ENUM_VARIANT_LEN: u8 = Self::ENUM_VARIANT_START + Self::ENUM_VARIANT_INNER_LEN;
}
pub trait U8Index {
fn index(&self) -> usize;
}
impl U8Index for ZomeDependencyIndex {
fn index(&self) -> usize {
self.0 as usize
}
}
impl U8Index for EntryDefIndex {
fn index(&self) -> usize {
self.0 as usize
}
}
impl U8Index for LinkType {
fn index(&self) -> usize {
self.0 as usize
}
}
impl From<u8> for ZomeDependencyIndex {
fn from(v: u8) -> Self {
Self(v)
}
}
impl From<()> for ZomeEntryTypesKey {
fn from(_: ()) -> Self {
unimplemented!("Should not ever be used")
}
}