1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! This crate contains the core types of the [Ockam][main-ockam-crate-link]
//! library and is intended for use by crates that provide features and add-ons
//! to the main [Ockam][main-ockam-crate-link] library.
//!
//! The main [Ockam][main-ockam-crate-link] crate re-exports types defined in
//! this crate.
//!
//! ## Crate Features
//!
//! The `ockam_core` crate has a Cargo feature named `"std"` that is enabled by
//! default. In order to use this crate in a `no_std` context this feature can
//! be disabled as follows
//!
//! ```toml
//! [dependencies]
//! ockam_core = { version = "<current version>" , default-features = false }
//! ```
//!
//! Please note that Cargo features are unioned across the entire dependency
//! graph of a project. If any other crate you depend on has not opted out of
//! `ockam_core` default features, Cargo will build `ockam_core` with the std
//! feature enabled whether or not your direct dependency on `ockam_core`
//! has `default-features = false`.
//!
#![deny(unsafe_code)]
#![warn(
    missing_docs,
    trivial_casts,
    trivial_numeric_casts,
    unused_import_braces,
    unused_qualifications
)]
#![cfg_attr(not(feature = "std"), no_std)]

#[cfg(all(not(feature = "std"), not(feature = "alloc")))]
compile_error!(r#"The "no_std" feature currently requires the "alloc" feature"#);

#[cfg(feature = "std")]
extern crate core;

#[cfg(feature = "alloc")]
#[macro_use]
extern crate alloc;

// Allow use of logging macros directly.
#[macro_use]
extern crate tracing;

pub use async_trait::async_trait;

/// Mark an Ockam Worker implementation.
#[doc(inline)]
pub use async_trait::async_trait as worker;
/// Mark an Ockam Processor implementation.
#[doc(inline)]
pub use async_trait::async_trait as processor;

extern crate ockam_macros;

pub use ockam_macros::{AsyncTryClone, Message};

extern crate futures_util;

/// Access control
pub mod access_control;
pub mod api;
pub mod compat;

/// Debugger
pub mod debugger;
pub mod flow_control;

/// Encoding
pub mod hex_encoding;

/// Environmental variables
#[cfg(feature = "std")]
pub mod env;

pub mod bare;
mod cbor;
mod error;
mod message;
mod processor;
mod routing;
mod uint;
mod worker;

pub use access_control::*;
pub use cbor::*;
pub use error::*;
pub use message::*;
pub use processor::*;
pub use routing::*;
pub use uint::*;
pub use worker::*;

#[cfg(all(not(feature = "std"), feature = "alloc"))]
#[doc(hidden)]
pub use compat::println;

#[cfg(feature = "std")]
#[doc(hidden)]
pub use std::println;

use crate::compat::boxed::Box;

/// Clone trait for async structs.
#[async_trait]
pub trait AsyncTryClone: Sized {
    /// Try cloning a object and return an `Err` in case of failure.
    async fn async_try_clone(&self) -> Result<Self>;
}

#[async_trait]
impl<D> AsyncTryClone for D
where
    D: Clone + Sync,
{
    async fn async_try_clone(&self) -> Result<Self> {
        Ok(self.clone())
    }
}

/// Produces Ok(false) to avoid an ambiguous reading from using the unadorned value in auth code.
#[inline]
pub fn deny() -> Result<bool> {
    Ok(false)
}

/// Produces Ok(true) to avoid an ambiguous reading from using the unadorned value in auth code.
#[inline]
pub fn allow() -> Result<bool> {
    Ok(true)
}