pub const NAMESPACE_NAME_MAX_BYTES: usize = 255;
pub const SET_FLAGS_BYTES: usize = 1;
pub const SET_CONDITION_MASK: u8 = 0x03;
pub const SET_CONDITION_ANY_BITS: u8 = 0x00;
pub const SET_IF_ABSENT_BITS: u8 = 0x01;
pub const SET_IF_PRESENT_BITS: u8 = 0x02;
pub const SET_CONDITION_RESERVED_BITS: u8 = 0x03;
pub const SET_EXPIRATION_MASK: u8 = 0x0c;
pub const SET_INHERIT_EXPIRATION_BITS: u8 = 0x00;
pub const SET_NO_EXPIRY_BITS: u8 = 0x04;
pub const SET_EXPLICIT_TTL_BITS: u8 = 0x08;
pub const SET_EXPIRATION_RESERVED_BITS: u8 = 0x0c;
pub const SET_EVICTION_MASK: u8 = 0x30;
pub const SET_INHERIT_EVICTION_BITS: u8 = 0x00;
pub const SET_EVICTABLE_BITS: u8 = 0x10;
pub const SET_EVICTION_PROTECTED_BITS: u8 = 0x20;
pub const SET_EVICTION_RESERVED_BITS: u8 = 0x30;
pub const SET_RESERVED_MASK: u8 = 0xc0;
pub const OPEN_FLAGS_BYTES: usize = 1;
pub const OPEN_CREATE_IF_MISSING: u8 = 0x01;
pub const OPEN_RESERVED_MASK: u8 = 0xfe;
pub const DELETE_FLAGS_BYTES: usize = 1;
pub const DELETE_IF_EMPTY: u8 = 0x00;
pub const DELETE_MODE_MASK: u8 = 0x03;
pub const DELETE_RESERVED_MASK: u8 = 0xfc;
pub const POLICY_FLAGS_BYTES: usize = 1;
pub const POLICY_DEFAULT_EXPIRATION_MASK: u8 = 0x03;
pub const POLICY_NO_EXPIRY: u8 = 0x00;
pub const POLICY_FIXED_TTL: u8 = 0x01;
pub const POLICY_DEFAULT_EXPIRATION_RESERVED_BITS: u8 = 0x03;
pub const POLICY_EXPIRATION_OVERRIDE: u8 = 0x04;
pub const POLICY_EVICTION_PROTECTED: u8 = 0x08;
pub const POLICY_EVICTION_OVERRIDE: u8 = 0x10;
pub const POLICY_RESERVED_MASK: u8 = 0xe0;
pub const DEFAULT_MAX_IN_FLIGHT: usize = 256;
pub const MAX_CANONICAL_KEY_BYTES: usize = 1_048_576;
pub const DEFAULT_CONNECT_TIMEOUT_MILLISECONDS: u64 = 5_000;
pub const DEFAULT_REQUEST_TIMEOUT_MILLISECONDS: u64 = 2_000;
pub const DEFAULT_RETRY_MAX_ATTEMPTS: usize = 2;
pub const DEFAULT_ZSTANDARD_LEVEL: i32 = 1;
pub const DEFAULT_ZSTANDARD_MINIMUM_INPUT_BYTES: usize = 0;
pub const DEFAULT_ZSTANDARD_MINIMUM_SAVINGS_BYTES: usize = 0;
pub const DEFAULT_ZSTANDARD_LEVEL_MIN: i32 = 1;
pub const DEFAULT_ZSTANDARD_LEVEL_MAX: i32 = 22;
pub const CLIENT_DEFAULT_SERVER_NAME: &str = "localhost";
pub const CLIENT_CERTIFICATE_PEM_TYPE: &str = "CERTIFICATE";
pub const CLIENT_MINIMUM_POSITIVE_VALUE: usize = 1;
pub const CLIENT_GATE0_ALPN_VERSION: u32 = 1;
pub const CLIENT_GATE0_COMPRESSION: u8 = 0x00;
pub const CLIENT_GATE0_ENCRYPTION: u8 = 0x00;
pub const CLIENT_GATE0_ITEM_ID_ROOT: [u8; 32] = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f];
pub const CLIENT_GATE0_NAMESPACE_ID: u64 = 1;
pub const CLIENT_GATE0_VALUE_SELECTOR: u8 = 0x10;
pub const GATE0_NAMESPACE_ID: u64 = CLIENT_GATE0_NAMESPACE_ID;
pub const GATE0_ITEM_ID_ROOT: [u8; 32] = CLIENT_GATE0_ITEM_ID_ROOT;
pub const GATE0_VALUE_FORMAT_SELECTOR: u8 = CLIENT_GATE0_VALUE_SELECTOR;
pub const FFI_ABI_VERSION: u32 = 1;
pub const FFI_OPERATION_GET_JSON: u32 = 16;
pub const FFI_OPERATION_SET_JSON: u32 = 17;
pub const FFI_OPERATION_GET_STRUCTURED: u32 = 18;
pub const FFI_OPERATION_SET_STRUCTURED: u32 = 19;
pub const FFI_OPERATION_GET_V0: u32 = 20;
pub const FFI_OPERATION_SET_V0: u32 = 21;
pub const FFI_OPERATION_RECONNECT: u32 = 4_294_967_041;
pub const FFI_RESULT_ERROR: u32 = 0;
pub const FFI_RESULT_OK: u32 = 1;
pub const FFI_RESULT_VALUE: u32 = 2;
pub const FFI_RESULT_NOT_FOUND: u32 = 3;
pub const FFI_RESULT_CREATED: u32 = 4;
pub const FFI_RESULT_REPLACED: u32 = 5;
pub const FFI_RESULT_DELETED: u32 = 6;
pub const FFI_RESULT_NOT_DELETED: u32 = 7;
pub const FFI_RESULT_CONNECTED: u32 = 8;
pub const FFI_RESULT_NOT_STORED: u32 = 9;
pub const FFI_RESULT_RAW: u32 = 10;
pub const FFI_RESULT_CANCELED: u32 = 11;
pub const FFI_RESULT_UNKNOWN_MUTATION: u32 = 12;
pub const FFI_RESULT_RESOURCE_EXHAUSTED: u32 = 13;
pub const FFI_STATUS_CATEGORY_SUCCESS: u32 = 0;
pub const FFI_STATUS_CATEGORY_NOT_FOUND: u32 = 1;
pub const FFI_STATUS_CATEGORY_MUTATION: u32 = 2;
pub const FFI_STATUS_CATEGORY_ERROR: u32 = 3;
pub const FFI_STATUS_CATEGORY_CANCELED: u32 = 4;
pub const FFI_STATUS_CATEGORY_UNKNOWN_MUTATION: u32 = 5;
pub const FFI_STATUS_CATEGORY_RESOURCE_EXHAUSTED: u32 = 6;
pub const FFI_ERROR_CATEGORY_NONE: u32 = 0;
pub const FFI_ERROR_CATEGORY_INVALID_INPUT: u32 = 1;
pub const FFI_ERROR_CATEGORY_CONFIGURATION: u32 = 2;
pub const FFI_ERROR_CATEGORY_TIMEOUT: u32 = 3;
pub const FFI_ERROR_CATEGORY_TRANSPORT: u32 = 4;
pub const FFI_ERROR_CATEGORY_SERVER: u32 = 5;
pub const FFI_ERROR_CATEGORY_PROTOCOL: u32 = 6;
pub const FFI_ERROR_CATEGORY_VALUE: u32 = 7;
pub const FFI_ERROR_CATEGORY_KEY: u32 = 8;
pub const FFI_ERROR_CATEGORY_CANCELED: u32 = 9;
pub const FFI_ERROR_CATEGORY_UNKNOWN_MUTATION: u32 = 10;
pub const FFI_ERROR_CATEGORY_RESOURCE_EXHAUSTED: u32 = 11;
pub const FFI_ERROR_CATEGORY_CLOSED: u32 = 12;
pub const FFI_ERROR_CATEGORY_INTERNAL: u32 = 13;
pub const FFI_REQUEST_STATE_PENDING: u32 = 0;
pub const FFI_REQUEST_STATE_READY: u32 = 1;
pub const FFI_REQUEST_STATE_CANCELED: u32 = 2;
pub const FFI_REQUEST_STATE_CONSUMED: u32 = 3;
pub const FFI_REQUEST_STATE_FREED: u32 = 4;
pub const FFI_VALUE_REPRESENTATION_LOSSLESS: u32 = 0;
pub const FFI_VALUE_REPRESENTATION_NATIVE: u32 = 1;
pub const FFI_VALUE_MODE_FORMATTED_V1: u32 = 0;
pub const FFI_VALUE_MODE_RAW: u32 = 1;
pub const FFI_VALUE_MODE_CALLER_OWNED_V0: u32 = 2;
pub const FFI_CONNECTION_STATE_CONNECTED: u32 = 0;
pub const FFI_CONNECTION_STATE_RECONNECTING: u32 = 1;
pub const FFI_CONNECTION_STATE_DISCONNECTED: u32 = 2;
pub const FFI_CONNECTION_STATE_CLOSED: u32 = 3;
pub const FFI_CONNECTION_STATE_UNKNOWN: u32 = 4;
pub const FFI_TRANSPORT_QUIC: u32 = 0;
pub const FFI_TRANSPORT_TLS_TCP: u32 = 1;
pub const FFI_TRANSPORT_QUIC_INSECURE: u32 = 2;
pub const FFI_TRANSPORT_TLS_TCP_INSECURE: u32 = 3;
pub const FFI_SET_CONDITION_ANY: u32 = 0;
pub const FFI_SET_CONDITION_IF_ABSENT: u32 = 1;
pub const FFI_SET_CONDITION_IF_PRESENT: u32 = 2;
pub const FFI_KEY_SPEC_TEXT: u32 = 0;
pub const FFI_KEY_SPEC_BYTES: u32 = 1;
pub const FFI_KEY_SPEC_INTEGER: u32 = 2;
pub const FFI_NAMESPACE_DESCRIPTOR_DECODE_OK: u32 = 0;
pub const FFI_NAMESPACE_DESCRIPTOR_DECODE_INVALID: u32 = 1;
pub const FFI_NAMESPACE_DEFAULT_EXPIRATION_NO_EXPIRY: u32 = 0;
pub const FFI_NAMESPACE_DEFAULT_EXPIRATION_FIXED_TTL: u32 = 1;
pub const FFI_NAMESPACE_DEFAULT_EVICTION_EVICTABLE: u32 = 0;
pub const FFI_NAMESPACE_DEFAULT_EVICTION_PROTECTED: u32 = 1;
pub const FFI_NAMESPACE_OVERRIDE_DISALLOWED: u32 = 0;
pub const FFI_NAMESPACE_OVERRIDE_ALLOWED: u32 = 1;
pub const FFI_NAMESPACE_DESCRIPTOR_SIZE_BYTES: usize = 40;
pub const FFI_NAMESPACE_DESCRIPTOR_NAMESPACE_ID_OFFSET: usize = 0;
pub const FFI_NAMESPACE_DESCRIPTOR_REVISION_OFFSET: usize = 8;
pub const FFI_NAMESPACE_DESCRIPTOR_DEFAULT_TTL_MS_OFFSET: usize = 16;
pub const FFI_NAMESPACE_DESCRIPTOR_DEFAULT_EXPIRATION_OFFSET: usize = 24;
pub const FFI_NAMESPACE_DESCRIPTOR_EXPIRATION_OVERRIDE_OFFSET: usize = 28;
pub const FFI_NAMESPACE_DESCRIPTOR_DEFAULT_EVICTION_OFFSET: usize = 32;
pub const FFI_NAMESPACE_DESCRIPTOR_EVICTION_OVERRIDE_OFFSET: usize = 36;
#[repr(C)]
#[derive(Clone, Copy, Debug, Default)]
pub struct FfiNamespaceDescriptor {
pub namespace_id: u64,
pub revision: u64,
pub default_ttl_ms: u64,
pub default_expiration: u32,
pub expiration_override: u32,
pub default_eviction: u32,
pub eviction_override: u32,
}
const _: () = {
assert!(
core::mem::size_of::<FfiNamespaceDescriptor>()
== FFI_NAMESPACE_DESCRIPTOR_SIZE_BYTES
);
assert!(
core::mem::offset_of!(FfiNamespaceDescriptor, namespace_id)
== FFI_NAMESPACE_DESCRIPTOR_NAMESPACE_ID_OFFSET
);
assert!(
core::mem::offset_of!(FfiNamespaceDescriptor, revision)
== FFI_NAMESPACE_DESCRIPTOR_REVISION_OFFSET
);
assert!(
core::mem::offset_of!(FfiNamespaceDescriptor, default_ttl_ms)
== FFI_NAMESPACE_DESCRIPTOR_DEFAULT_TTL_MS_OFFSET
);
assert!(
core::mem::offset_of!(FfiNamespaceDescriptor, default_expiration)
== FFI_NAMESPACE_DESCRIPTOR_DEFAULT_EXPIRATION_OFFSET
);
assert!(
core::mem::offset_of!(FfiNamespaceDescriptor, expiration_override)
== FFI_NAMESPACE_DESCRIPTOR_EXPIRATION_OVERRIDE_OFFSET
);
assert!(
core::mem::offset_of!(FfiNamespaceDescriptor, default_eviction)
== FFI_NAMESPACE_DESCRIPTOR_DEFAULT_EVICTION_OFFSET
);
assert!(
core::mem::offset_of!(FfiNamespaceDescriptor, eviction_override)
== FFI_NAMESPACE_DESCRIPTOR_EVICTION_OVERRIDE_OFFSET
);
};
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct FfiOperationField {
pub data: *const u8,
pub length: usize,
pub present: u8,
}
pub const SMITHY_EVICTION_DEFAULT_EVICTABLE: &str = "evictable";
pub const SMITHY_EVICTION_DEFAULT_EVICTION_PROTECTED: &str = "eviction_protected";
pub const SMITHY_EVICTION_MODE_INHERIT: &str = "inherit";
pub const SMITHY_EVICTION_MODE_EVICTABLE: &str = "evictable";
pub const SMITHY_EVICTION_MODE_EVICTION_PROTECTED: &str = "eviction_protected";
pub const SMITHY_EXPIRATION_DEFAULT_NO_EXPIRY: &str = "no_expiry";
pub const SMITHY_EXPIRATION_DEFAULT_FIXED_TTL: &str = "fixed_ttl";
pub const SMITHY_EXPIRATION_MODE_INHERIT: &str = "inherit";
pub const SMITHY_EXPIRATION_MODE_NO_EXPIRY: &str = "no_expiry";
pub const SMITHY_EXPIRATION_MODE_EXPLICIT_TTL: &str = "explicit_ttl";
pub const SMITHY_OVERRIDE_POLICY_ALLOWED: &str = "allowed";
pub const SMITHY_OVERRIDE_POLICY_DISALLOWED: &str = "disallowed";
pub const SMITHY_SET_CONDITION_ANY: &str = "any";
pub const SMITHY_SET_CONDITION_IF_ABSENT: &str = "if_absent";
pub const SMITHY_SET_CONDITION_IF_PRESENT: &str = "if_present";
pub const SMITHY_SET_OUTCOME_CREATED: &str = "created";
pub const SMITHY_SET_OUTCOME_REPLACED: &str = "replaced";
pub const SMITHY_SET_OUTCOME_NOT_STORED: &str = "not_stored";
pub use crate::internal_protocol::operation::{
OperationFieldLayout,
OperationFramePolicy,
OperationFieldPlan,
OperationLayoutFraming,
OperationLayoutPlan,
OperationRequestFraming,
OperationResponseFraming,
OperationWireSpec,
WireCodecDescriptor,
WireCodecKind,
MAX_OPERATION_FIELDS,
MAX_OPERATION_REQUEST_FIELDS,
OPERATION_CODEC_NAMES,
WIRE_CODEC_DESCRIPTORS,
WIRE_CODEC_NAMES,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum OperationRetryMode {
Always,
Never,
WhenNotCreating,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct OperationResultSpec {
pub response_semantics: &'static str,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct OperationClientProjection {
pub retry_mode: OperationRetryMode,
pub result: OperationResultSpec,
}
pub const OPERATION_CLIENT_PROJECTIONS: [OperationClientProjection; crate::internal_protocol::Opcode::COUNT] = [
OperationClientProjection {
retry_mode: OperationRetryMode::Always,
result: OperationResultSpec {
response_semantics: "pong",
},
},
OperationClientProjection {
retry_mode: OperationRetryMode::Always,
result: OperationResultSpec {
response_semantics: "value",
},
},
OperationClientProjection {
retry_mode: OperationRetryMode::Never,
result: OperationResultSpec {
response_semantics: "set_outcome",
},
},
OperationClientProjection {
retry_mode: OperationRetryMode::Never,
result: OperationResultSpec {
response_semantics: "delete_outcome",
},
},
OperationClientProjection {
retry_mode: OperationRetryMode::Always,
result: OperationResultSpec {
response_semantics: "stats_json",
},
},
OperationClientProjection {
retry_mode: OperationRetryMode::Never,
result: OperationResultSpec {
response_semantics: "empty",
},
},
OperationClientProjection {
retry_mode: OperationRetryMode::WhenNotCreating,
result: OperationResultSpec {
response_semantics: "namespace_descriptor",
},
},
OperationClientProjection {
retry_mode: OperationRetryMode::Never,
result: OperationResultSpec {
response_semantics: "namespace_descriptor",
},
},
OperationClientProjection {
retry_mode: OperationRetryMode::Never,
result: OperationResultSpec {
response_semantics: "delete_outcome",
},
}
];
pub const fn operation_wire_spec(
opcode: crate::internal_protocol::Opcode,
) -> OperationWireSpec {
crate::internal_protocol::operation::operation_wire_spec(opcode)
}
pub const fn operation_client_projection(
opcode: crate::internal_protocol::Opcode,
) -> Option<OperationClientProjection> {
Some(OPERATION_CLIENT_PROJECTIONS[opcode.index()])
}
pub fn wire_codec_kind(
name: &str,
) -> Option<crate::internal_protocol::codec::CodecKind> {
crate::internal_protocol::wire_codec_kind(name)
}
pub const fn operation_result_kind(
opcode: crate::internal_protocol::Opcode,
status: crate::internal_protocol::Status,
) -> Option<FfiResultKind> {
match opcode {
crate::internal_protocol::Opcode::Ping => match status {
crate::internal_protocol::Status::Ok => Some(FfiResultKind::Ok),
_ => None,
},
crate::internal_protocol::Opcode::Get => match status {
crate::internal_protocol::Status::Ok => Some(FfiResultKind::Value),
crate::internal_protocol::Status::NotFound => Some(FfiResultKind::NotFound),
_ => None,
},
crate::internal_protocol::Opcode::Set => match status {
crate::internal_protocol::Status::Created => Some(FfiResultKind::Created),
crate::internal_protocol::Status::Replaced => Some(FfiResultKind::Replaced),
crate::internal_protocol::Status::NotStored => Some(FfiResultKind::NotStored),
_ => None,
},
crate::internal_protocol::Opcode::Delete => match status {
crate::internal_protocol::Status::Deleted => Some(FfiResultKind::Deleted),
crate::internal_protocol::Status::NotFound => Some(FfiResultKind::NotDeleted),
_ => None,
},
crate::internal_protocol::Opcode::ExperimentalStats => match status {
crate::internal_protocol::Status::Ok => Some(FfiResultKind::Value),
_ => None,
},
crate::internal_protocol::Opcode::ExperimentalSync => match status {
crate::internal_protocol::Status::Ok => Some(FfiResultKind::Ok),
_ => None,
},
crate::internal_protocol::Opcode::NamespaceOpen => match status {
crate::internal_protocol::Status::Ok => Some(FfiResultKind::Ok),
crate::internal_protocol::Status::Created => Some(FfiResultKind::Created),
_ => None,
},
crate::internal_protocol::Opcode::NamespaceUpdatePolicy => match status {
crate::internal_protocol::Status::Ok => Some(FfiResultKind::Value),
_ => None,
},
crate::internal_protocol::Opcode::NamespaceDelete => match status {
crate::internal_protocol::Status::Deleted => Some(FfiResultKind::Ok),
_ => None,
},
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiOperation {
Ping = 1,
Get = 2,
Set = 3,
Delete = 4,
ExperimentalStats = 5,
ExperimentalSync = 6,
NamespaceOpen = 7,
NamespaceUpdatePolicy = 8,
NamespaceDelete = 9,
GetJson = 16,
SetJson = 17,
GetStructured = 18,
SetStructured = 19,
GetV0 = 20,
SetV0 = 21,
Reconnect = 4_294_967_041,
}
impl FfiOperation {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiOperation {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::Ping.code() => Ok(Self::Ping),
value if value == Self::Get.code() => Ok(Self::Get),
value if value == Self::Set.code() => Ok(Self::Set),
value if value == Self::Delete.code() => Ok(Self::Delete),
value if value == Self::ExperimentalStats.code() => Ok(Self::ExperimentalStats),
value if value == Self::ExperimentalSync.code() => Ok(Self::ExperimentalSync),
value if value == Self::NamespaceOpen.code() => Ok(Self::NamespaceOpen),
value if value == Self::NamespaceUpdatePolicy.code() => Ok(Self::NamespaceUpdatePolicy),
value if value == Self::NamespaceDelete.code() => Ok(Self::NamespaceDelete),
value if value == Self::GetJson.code() => Ok(Self::GetJson),
value if value == Self::SetJson.code() => Ok(Self::SetJson),
value if value == Self::GetStructured.code() => Ok(Self::GetStructured),
value if value == Self::SetStructured.code() => Ok(Self::SetStructured),
value if value == Self::GetV0.code() => Ok(Self::GetV0),
value if value == Self::SetV0.code() => Ok(Self::SetV0),
value if value == Self::Reconnect.code() => Ok(Self::Reconnect),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiOperation {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::Ping => "ping",
Self::Get => "get",
Self::Set => "set",
Self::Delete => "delete",
Self::ExperimentalStats => "experimental_stats",
Self::ExperimentalSync => "experimental_sync",
Self::NamespaceOpen => "namespace_open",
Self::NamespaceUpdatePolicy => "namespace_update_policy",
Self::NamespaceDelete => "namespace_delete",
Self::GetJson => "get_json",
Self::SetJson => "set_json",
Self::GetStructured => "get_structured",
Self::SetStructured => "set_structured",
Self::GetV0 => "get_v0",
Self::SetV0 => "set_v0",
Self::Reconnect => "reconnect",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum FfiInputKind {
None,
ApplicationKey,
ItemId,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct FfiOperationContract {
pub input_kind: FfiInputKind,
pub request_item_count: usize,
pub accepts_value: bool,
pub accepts_set_options: bool,
pub supports_protected: bool,
pub supports_raw: bool,
pub supports_scoped: bool,
pub dedicated_abi: bool,
}
pub const fn ffi_operation_contract(
operation: FfiOperation,
) -> FfiOperationContract {
match operation {
FfiOperation::Ping => FfiOperationContract {
input_kind: FfiInputKind::None,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: true,
supports_raw: true,
supports_scoped: false,
dedicated_abi: false,
},
FfiOperation::Get => FfiOperationContract {
input_kind: FfiInputKind::ItemId,
request_item_count: 1,
accepts_value: false,
accepts_set_options: false,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::Set => FfiOperationContract {
input_kind: FfiInputKind::ItemId,
request_item_count: 1,
accepts_value: true,
accepts_set_options: true,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::Delete => FfiOperationContract {
input_kind: FfiInputKind::ItemId,
request_item_count: 1,
accepts_value: false,
accepts_set_options: false,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::ExperimentalStats => FfiOperationContract {
input_kind: FfiInputKind::None,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::ExperimentalSync => FfiOperationContract {
input_kind: FfiInputKind::None,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::NamespaceOpen => FfiOperationContract {
input_kind: FfiInputKind::None,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: false,
supports_raw: false,
supports_scoped: false,
dedicated_abi: true,
},
FfiOperation::NamespaceUpdatePolicy => FfiOperationContract {
input_kind: FfiInputKind::None,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: false,
supports_raw: false,
supports_scoped: false,
dedicated_abi: true,
},
FfiOperation::NamespaceDelete => FfiOperationContract {
input_kind: FfiInputKind::None,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: false,
supports_raw: false,
supports_scoped: false,
dedicated_abi: true,
},
FfiOperation::GetJson => FfiOperationContract {
input_kind: FfiInputKind::ApplicationKey,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::SetJson => FfiOperationContract {
input_kind: FfiInputKind::ApplicationKey,
request_item_count: 0,
accepts_value: true,
accepts_set_options: true,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::GetStructured => FfiOperationContract {
input_kind: FfiInputKind::ApplicationKey,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::SetStructured => FfiOperationContract {
input_kind: FfiInputKind::ApplicationKey,
request_item_count: 0,
accepts_value: true,
accepts_set_options: true,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::GetV0 => FfiOperationContract {
input_kind: FfiInputKind::ApplicationKey,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::SetV0 => FfiOperationContract {
input_kind: FfiInputKind::ApplicationKey,
request_item_count: 0,
accepts_value: true,
accepts_set_options: true,
supports_protected: true,
supports_raw: true,
supports_scoped: true,
dedicated_abi: false,
},
FfiOperation::Reconnect => FfiOperationContract {
input_kind: FfiInputKind::None,
request_item_count: 0,
accepts_value: false,
accepts_set_options: false,
supports_protected: true,
supports_raw: true,
supports_scoped: false,
dedicated_abi: false,
},
}
}
pub const fn protocol_opcode(
operation: FfiOperation,
) -> Option<crate::internal_protocol::Opcode> {
match operation {
FfiOperation::Ping => Some(crate::internal_protocol::Opcode::Ping),
FfiOperation::Get => Some(crate::internal_protocol::Opcode::Get),
FfiOperation::Set => Some(crate::internal_protocol::Opcode::Set),
FfiOperation::Delete => Some(crate::internal_protocol::Opcode::Delete),
FfiOperation::ExperimentalStats => Some(crate::internal_protocol::Opcode::ExperimentalStats),
FfiOperation::ExperimentalSync => Some(crate::internal_protocol::Opcode::ExperimentalSync),
FfiOperation::NamespaceOpen => Some(crate::internal_protocol::Opcode::NamespaceOpen),
FfiOperation::NamespaceUpdatePolicy => Some(crate::internal_protocol::Opcode::NamespaceUpdatePolicy),
FfiOperation::NamespaceDelete => Some(crate::internal_protocol::Opcode::NamespaceDelete),
_ => None,
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiResultKind {
Error = 0,
Ok = 1,
Value = 2,
NotFound = 3,
Created = 4,
Replaced = 5,
Deleted = 6,
NotDeleted = 7,
Connected = 8,
NotStored = 9,
Raw = 10,
Canceled = 11,
UnknownMutation = 12,
ResourceExhausted = 13,
}
impl FfiResultKind {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiResultKind {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::Error.code() => Ok(Self::Error),
value if value == Self::Ok.code() => Ok(Self::Ok),
value if value == Self::Value.code() => Ok(Self::Value),
value if value == Self::NotFound.code() => Ok(Self::NotFound),
value if value == Self::Created.code() => Ok(Self::Created),
value if value == Self::Replaced.code() => Ok(Self::Replaced),
value if value == Self::Deleted.code() => Ok(Self::Deleted),
value if value == Self::NotDeleted.code() => Ok(Self::NotDeleted),
value if value == Self::Connected.code() => Ok(Self::Connected),
value if value == Self::NotStored.code() => Ok(Self::NotStored),
value if value == Self::Raw.code() => Ok(Self::Raw),
value if value == Self::Canceled.code() => Ok(Self::Canceled),
value if value == Self::UnknownMutation.code() => Ok(Self::UnknownMutation),
value if value == Self::ResourceExhausted.code() => Ok(Self::ResourceExhausted),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiResultKind {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::Error => "error",
Self::Ok => "ok",
Self::Value => "value",
Self::NotFound => "not_found",
Self::Created => "created",
Self::Replaced => "replaced",
Self::Deleted => "deleted",
Self::NotDeleted => "not_deleted",
Self::Connected => "connected",
Self::NotStored => "not_stored",
Self::Raw => "raw",
Self::Canceled => "canceled",
Self::UnknownMutation => "unknown_mutation",
Self::ResourceExhausted => "resource_exhausted",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiStatusCategory {
Success = 0,
NotFound = 1,
Mutation = 2,
Error = 3,
Canceled = 4,
UnknownMutation = 5,
ResourceExhausted = 6,
}
impl FfiStatusCategory {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiStatusCategory {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::Success.code() => Ok(Self::Success),
value if value == Self::NotFound.code() => Ok(Self::NotFound),
value if value == Self::Mutation.code() => Ok(Self::Mutation),
value if value == Self::Error.code() => Ok(Self::Error),
value if value == Self::Canceled.code() => Ok(Self::Canceled),
value if value == Self::UnknownMutation.code() => Ok(Self::UnknownMutation),
value if value == Self::ResourceExhausted.code() => Ok(Self::ResourceExhausted),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiStatusCategory {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::Success => "success",
Self::NotFound => "not_found",
Self::Mutation => "mutation",
Self::Error => "error",
Self::Canceled => "canceled",
Self::UnknownMutation => "unknown_mutation",
Self::ResourceExhausted => "resource_exhausted",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiTransport {
Quic = 0,
TlsTcp = 1,
QuicInsecure = 2,
TlsTcpInsecure = 3,
}
impl FfiTransport {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiTransport {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::Quic.code() => Ok(Self::Quic),
value if value == Self::TlsTcp.code() => Ok(Self::TlsTcp),
value if value == Self::QuicInsecure.code() => Ok(Self::QuicInsecure),
value if value == Self::TlsTcpInsecure.code() => Ok(Self::TlsTcpInsecure),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiTransport {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::Quic => "quic",
Self::TlsTcp => "tls_tcp",
Self::QuicInsecure => "quic_insecure",
Self::TlsTcpInsecure => "tls_tcp_insecure",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiErrorCategory {
None = 0,
InvalidInput = 1,
Configuration = 2,
Timeout = 3,
Transport = 4,
Server = 5,
Protocol = 6,
Value = 7,
Key = 8,
Canceled = 9,
UnknownMutation = 10,
ResourceExhausted = 11,
Closed = 12,
Internal = 13,
}
impl FfiErrorCategory {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiErrorCategory {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::None.code() => Ok(Self::None),
value if value == Self::InvalidInput.code() => Ok(Self::InvalidInput),
value if value == Self::Configuration.code() => Ok(Self::Configuration),
value if value == Self::Timeout.code() => Ok(Self::Timeout),
value if value == Self::Transport.code() => Ok(Self::Transport),
value if value == Self::Server.code() => Ok(Self::Server),
value if value == Self::Protocol.code() => Ok(Self::Protocol),
value if value == Self::Value.code() => Ok(Self::Value),
value if value == Self::Key.code() => Ok(Self::Key),
value if value == Self::Canceled.code() => Ok(Self::Canceled),
value if value == Self::UnknownMutation.code() => Ok(Self::UnknownMutation),
value if value == Self::ResourceExhausted.code() => Ok(Self::ResourceExhausted),
value if value == Self::Closed.code() => Ok(Self::Closed),
value if value == Self::Internal.code() => Ok(Self::Internal),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiErrorCategory {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::None => "none",
Self::InvalidInput => "invalid_input",
Self::Configuration => "configuration",
Self::Timeout => "timeout",
Self::Transport => "transport",
Self::Server => "server",
Self::Protocol => "protocol",
Self::Value => "value",
Self::Key => "key",
Self::Canceled => "canceled",
Self::UnknownMutation => "unknown_mutation",
Self::ResourceExhausted => "resource_exhausted",
Self::Closed => "closed",
Self::Internal => "internal",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiRequestState {
Pending = 0,
Ready = 1,
Canceled = 2,
Consumed = 3,
Freed = 4,
}
impl FfiRequestState {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiRequestState {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::Pending.code() => Ok(Self::Pending),
value if value == Self::Ready.code() => Ok(Self::Ready),
value if value == Self::Canceled.code() => Ok(Self::Canceled),
value if value == Self::Consumed.code() => Ok(Self::Consumed),
value if value == Self::Freed.code() => Ok(Self::Freed),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiRequestState {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::Pending => "pending",
Self::Ready => "ready",
Self::Canceled => "canceled",
Self::Consumed => "consumed",
Self::Freed => "freed",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiValueRepresentation {
Lossless = 0,
Native = 1,
}
impl FfiValueRepresentation {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiValueRepresentation {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::Lossless.code() => Ok(Self::Lossless),
value if value == Self::Native.code() => Ok(Self::Native),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiValueRepresentation {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::Lossless => "lossless",
Self::Native => "native",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiValueMode {
FormattedV1 = 0,
Raw = 1,
CallerOwnedV0 = 2,
}
impl FfiValueMode {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiValueMode {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::FormattedV1.code() => Ok(Self::FormattedV1),
value if value == Self::Raw.code() => Ok(Self::Raw),
value if value == Self::CallerOwnedV0.code() => Ok(Self::CallerOwnedV0),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiValueMode {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::FormattedV1 => "formatted_v1",
Self::Raw => "raw",
Self::CallerOwnedV0 => "caller_owned_v0",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum ConnectionState {
Connected = 0,
Reconnecting = 1,
Disconnected = 2,
Closed = 3,
Unknown = 4,
}
impl ConnectionState {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for ConnectionState {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::Connected.code() => Ok(Self::Connected),
value if value == Self::Reconnecting.code() => Ok(Self::Reconnecting),
value if value == Self::Disconnected.code() => Ok(Self::Disconnected),
value if value == Self::Closed.code() => Ok(Self::Closed),
value if value == Self::Unknown.code() => Ok(Self::Unknown),
_ => Err(value),
}
}
}
impl core::fmt::Display for ConnectionState {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::Connected => "connected",
Self::Reconnecting => "reconnecting",
Self::Disconnected => "disconnected",
Self::Closed => "closed",
Self::Unknown => "unknown",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiSetCondition {
Any = 0,
IfAbsent = 1,
IfPresent = 2,
}
impl FfiSetCondition {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiSetCondition {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::Any.code() => Ok(Self::Any),
value if value == Self::IfAbsent.code() => Ok(Self::IfAbsent),
value if value == Self::IfPresent.code() => Ok(Self::IfPresent),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiSetCondition {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::Any => "any",
Self::IfAbsent => "if_absent",
Self::IfPresent => "if_present",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum FfiKeySpec {
Text = 0,
Bytes = 1,
Integer = 2,
}
impl FfiKeySpec {
pub const fn code(self) -> u32 {
self as u32
}
}
impl core::convert::TryFrom<u32> for FfiKeySpec {
type Error = u32;
fn try_from(value: u32) -> core::result::Result<Self, u32> {
match value {
value if value == Self::Text.code() => Ok(Self::Text),
value if value == Self::Bytes.code() => Ok(Self::Bytes),
value if value == Self::Integer.code() => Ok(Self::Integer),
_ => Err(value),
}
}
}
impl core::fmt::Display for FfiKeySpec {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::Text => "text",
Self::Bytes => "bytes",
Self::Integer => "integer",
})
}
}
pub const VALUE_FORMAT_VERSION: u128 = 1;
pub const VALUE_FORMAT_VERSION_BYTES: &[u8] = &[0x01];
pub const VALUE_FORMAT_MAX_VU128_BYTES: usize = 9;
pub const VALUE_FORMAT_FORMAT_BYTE_BYTES: usize = 1;
pub const VALUE_FORMAT_COMPRESSION_MASK: u8 = 0x0f;
pub const VALUE_FORMAT_ENCRYPTION_SHIFT: u8 = 0x04;
pub const VALUE_FORMAT_SERIALIZATION_RAW: u8 = 0x00;
pub const VALUE_FORMAT_SERIALIZATION_JSON: u8 = 0x01;
pub const VALUE_FORMAT_SERIALIZATION_STRUCTURED: u8 = 0x01;
pub const VALUE_FORMAT_COMPRESSION_NONE: u8 = 0x00;
pub const VALUE_FORMAT_COMPRESSION_ZSTANDARD: u8 = 0x01;
pub const VALUE_FORMAT_ENCRYPTION_NONE: u8 = 0x00;
pub const VALUE_FORMAT_ENCRYPTION_COMPACT: u8 = 0x02;
pub const VALUE_FORMAT_ENCRYPTION_ROBUST: u8 = 0x01;
pub const VALUE_FORMAT_COMPACT_SYNTHETIC_IV_BYTES: usize = 16;
pub const VALUE_FORMAT_ROBUST_NONCE_BYTES: usize = 12;
pub const VALUE_FORMAT_ROBUST_TAG_BYTES: usize = 16;
pub const VALUE_FORMAT_DATA_PROTECTION_KEY_BYTES: usize = 32;
pub const VALUE_FORMAT_ITEM_ID_ROOT_CONTEXT: &str = "OpenKache item ID derivation root v1";
pub const VALUE_FORMAT_AAD_DOMAIN: &[u8] = b"openkache/value-format/aad/v1";
pub const VALUE_FORMAT_VALUE_ROOT_CONTEXT: &str = "OpenKache value format v1 root key";
pub const VALUE_FORMAT_COMPACT_MAC_CONTEXT: &str = "OpenKache value format v1 AES-256-SIV-CMAC MAC key";
pub const VALUE_FORMAT_COMPACT_ENCRYPTION_CONTEXT: &str = "OpenKache value format v1 AES-256-SIV-CMAC encryption key";
pub const VALUE_FORMAT_ROBUST_CONTEXT: &str = "OpenKache value format v1 AES-256-GCM-SIV key";
pub const VALUE_ENVELOPE_MAGIC_AND_VERSION: [u8; 4] = [0x4f, 0x4b, 0x56, 0x01];
pub const VALUE_ENVELOPE_MAX_ENCODING_BYTES: usize = 64;
pub const VALUE_ENVELOPE_MAX_TYPE_NAME_BYTES: usize = 65_535;
pub const VALUE_ENVELOPE_JSON_ENCODING: &str = "json";