use crate::{types::*, uri::Lib3hUri, Address};
use std::cmp::Ordering;
#[derive(Clone, Eq, PartialEq, Deserialize, Serialize, Hash)]
pub struct Opaque(#[serde(with = "base64")] Vec<u8>);
impl Opaque {
pub fn new() -> Self {
Vec::new().into()
}
pub fn as_bytes(self) -> Vec<u8> {
self.0
}
}
impl From<Opaque> for Vec<u8> {
fn from(o: Opaque) -> Self {
o.0
}
}
impl From<Vec<u8>> for Opaque {
fn from(vec: Vec<u8>) -> Self {
Opaque(vec)
}
}
impl From<&[u8]> for Opaque {
fn from(bytes: &[u8]) -> Self {
Opaque(Vec::from(bytes))
}
}
impl From<String> for Opaque {
fn from(str: String) -> Self {
str.as_bytes().into()
}
}
impl From<&String> for Opaque {
fn from(str: &String) -> Self {
str.clone().into()
}
}
impl From<&str> for Opaque {
fn from(str: &str) -> Self {
str.as_bytes().into()
}
}
impl std::ops::Deref for Opaque {
type Target = Vec<u8>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl std::ops::DerefMut for Opaque {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, Hash)]
pub struct EntryAspectData {
pub aspect_address: AspectHash,
pub type_hint: String,
pub aspect: Opaque,
pub publish_ts: u64,
}
impl Ord for EntryAspectData {
fn cmp(&self, other: &Self) -> Ordering {
self.aspect_address.cmp(&other.aspect_address)
}
}
impl PartialOrd for EntryAspectData {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct EntryData {
pub entry_address: EntryHash,
pub aspect_list: Vec<EntryAspectData>,
}
impl EntryData {
pub fn new(address: &EntryHash) -> Self {
EntryData {
entry_address: address.clone(),
aspect_list: Vec::new(),
}
}
pub fn get(&self, aspect_address: &AspectHash) -> Option<EntryAspectData> {
for aspect in self.aspect_list.iter() {
if aspect.aspect_address == *aspect_address {
return Some(aspect.clone());
}
}
None
}
pub fn merge(&mut self, other: &EntryData) -> bool {
if self.entry_address != other.entry_address {
return false;
}
let mut to_append = Vec::new();
for aspect in other.aspect_list.iter() {
if self
.aspect_list
.iter()
.any(|a| a.aspect_address == aspect.aspect_address)
{
continue;
}
to_append.push(aspect.clone());
}
if to_append.len() == 0 {
return false;
}
self.aspect_list.append(&mut to_append);
true
}
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct GenericResultData {
pub request_id: String,
pub space_address: SpaceHash,
pub to_agent_id: AgentPubKey,
pub result_info: Opaque,
}
impl std::fmt::Debug for Opaque {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let bytes = String::from_utf8_lossy(self.0.as_ref());
write!(f, "{:?}", bytes)
}
}
impl std::fmt::Display for Opaque {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", self)
}
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct BootstrapData {
pub network_or_space_address: Address,
pub bootstrap_uri: Lib3hUri,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct ConnectData {
pub request_id: String,
pub peer_location: Lib3hUri,
pub network_id: NetworkHash,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct ConnectedData {
pub request_id: String,
pub uri: Lib3hUri,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct DisconnectedData {
pub network_id: NetworkHash,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct UnboundData {
pub uri: Lib3hUri,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct SpaceData {
pub request_id: String,
pub space_address: SpaceHash,
pub agent_id: AgentPubKey,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct DirectMessageData {
pub space_address: SpaceHash,
pub request_id: String,
pub to_agent_id: AgentPubKey,
pub from_agent_id: AgentPubKey,
pub content: Opaque,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct QueryEntryData {
pub space_address: SpaceHash,
pub entry_address: EntryHash,
pub request_id: String,
pub requester_agent_id: AgentPubKey,
pub query: Opaque,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct QueryEntryResultData {
pub space_address: SpaceHash,
pub entry_address: EntryHash,
pub request_id: String,
pub requester_agent_id: AgentPubKey,
pub responder_agent_id: AgentPubKey,
pub query_result: Opaque,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct ProvidedEntryData {
pub space_address: SpaceHash,
pub provider_agent_id: AgentPubKey,
pub entry: EntryData,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct StoreEntryAspectData {
pub request_id: String,
pub space_address: SpaceHash,
pub provider_agent_id: AgentPubKey,
pub entry_address: EntryHash,
pub entry_aspect: EntryAspectData,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct DropEntryData {
pub space_address: SpaceHash,
pub request_id: String,
pub entry_address: EntryHash,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct FetchEntryData {
pub space_address: SpaceHash,
pub entry_address: EntryHash,
pub request_id: String,
pub provider_agent_id: AgentPubKey,
pub aspect_address_list: Option<Vec<AspectHash>>,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct FetchEntryResultData {
pub space_address: SpaceHash,
pub provider_agent_id: AgentPubKey,
pub request_id: String,
pub entry: EntryData,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct GetListData {
pub space_address: SpaceHash,
pub provider_agent_id: AgentPubKey,
pub request_id: String,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct EntryListData {
pub space_address: SpaceHash,
pub provider_agent_id: AgentPubKey,
pub request_id: String,
pub address_map: std::collections::HashMap<EntryHash, Vec<AspectHash>>,
}
mod base64 {
extern crate base64;
use serde::{de, Deserialize, Deserializer, Serializer};
pub fn serialize<S>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(&base64::display::Base64Display::with_config(
bytes,
base64::STANDARD,
))
}
pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
where
D: Deserializer<'de>,
{
let s = <String>::deserialize(deserializer)?;
base64::decode(&s).map_err(de::Error::custom)
}
}