Struct CompactCiphertextList 

pub struct CompactCiphertextList { /* private fields */ }

Implementations

impl CompactCiphertextList

pub fn is_packed(&self) -> bool

pub fn needs_casting(&self) -> bool

pub fn builder(pk: &CompactPublicKey) -> CompactCiphertextListBuilder

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn get_kind_of(&self, index: usize) -> Option<DataKind>

pub fn into_raw_parts(self) -> (CompactCiphertextList, Vec<DataKind>)

Deconstruct a CompactCiphertextList into its constituents.

pub fn from_raw_parts( ct_list: CompactCiphertextList, info: Vec<DataKind>, ) -> Self

Construct a CompactCiphertextList from its constituents.

Panics

Panics if the constituents are not compatible with each others.

pub fn reinterpret_data(&mut self, info: &[DataKind]) -> Result<(), Error>

Allows to change the info about the data kind store in the CompactCiphertextList.

This can be useful if you are loading an old version of the CompactCiphertextList which did not store the metadata before.

The user is responsible of ensuring data consistency as the library cannot do that automatically. This can be a problem for boolean data if a block does not encrypt a 0 or a 1.

use tfhe::integer::ciphertext::{
    CompactCiphertextList, DataKind, IntegerCompactCiphertextListExpansionMode,
    RadixCiphertext, SignedRadixCiphertext,
};
use tfhe::integer::{ClientKey, CompactPublicKey};
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

let fhe_params = PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

let num_blocks = 4usize;

let cks = ClientKey::new(fhe_params);
let pk = CompactPublicKey::new(&cks);

let mut compact_ct = CompactCiphertextList::builder(&pk).push(-1i8).build();

let sanity_check_expander = compact_ct
    .expand(IntegerCompactCiphertextListExpansionMode::NoCastingAndNoUnpacking)
    .unwrap();
let sanity_expanded = sanity_check_expander
    .get::<SignedRadixCiphertext>(0)
    .unwrap()
    .unwrap();
let sanity_decrypted: i8 = cks.decrypt_signed_radix(&sanity_expanded);
assert_eq!(-1i8, sanity_decrypted);

compact_ct
    .reinterpret_data(&[DataKind::Unsigned(num_blocks.try_into().unwrap())])
    .unwrap();

let expander = compact_ct
    .expand(IntegerCompactCiphertextListExpansionMode::NoCastingAndNoUnpacking)
    .unwrap();

let expanded = expander.get::<RadixCiphertext>(0).unwrap().unwrap();
let decrypted: u8 = cks.decrypt_radix(&expanded);
// -1i8 == u8::MAX
assert_eq!(u8::MAX, decrypted);

pub fn ciphertext_count(&self) -> usize

pub fn expand( &self, expansion_mode: IntegerCompactCiphertextListExpansionMode<'_>, ) -> Result<CompactCiphertextListExpander>

pub fn size_elements(&self) -> usize

pub fn size_bytes(&self) -> usize

pub fn message_modulus(&self) -> MessageModulus

Trait Implementations

impl Clone for CompactCiphertextList

fn clone(&self) -> CompactCiphertextList

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for CompactCiphertextList

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ParameterSetConformant for CompactCiphertextList

type ParameterSet = CompactCiphertextListConformanceParams

fn is_conformant(&self, params: &CompactCiphertextListConformanceParams) -> bool

impl Serialize for CompactCiphertextList

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Unversionize for CompactCiphertextList

where CompactCiphertextListVersions: VersionsDispatch<Self>,

fn unversionize( versioned: Self::VersionedOwned, ) -> Result<Self, UnversionizeError>

Creates an object from a versioned enum, and eventually upgrades from previous variants.

impl UnversionizeVec for CompactCiphertextList

where CompactCiphertextListVersions: VersionsDispatch<Self>,

fn unversionize_vec( versioned: Self::VersionedVec, ) -> Result<Vec<Self>, UnversionizeError>

impl Upgrade<CompactCiphertextList> for CompactCiphertextListV0

type Error = Error

fn upgrade(self) -> Result<CompactCiphertextList, Self::Error>

impl Version for CompactCiphertextList

where CompactCiphertextList: VersionizeOwned + Unversionize + Versionize, Vec<DataKind>: VersionizeOwned + Unversionize + Versionize,

type Ref<'vers> = CompactCiphertextListVersion<'vers>

type Owned = CompactCiphertextListVersionOwned

impl Versionize for CompactCiphertextList

where CompactCiphertextListVersions: VersionsDispatch<Self>,

type Versioned<'vers> = <CompactCiphertextListVersions as VersionsDispatch<CompactCiphertextList>>::Ref<'vers>

The equivalent versioned type. It should have a variant for each version. It may own the underlying data or only hold a read-only reference to it.

fn versionize(&self) -> Self::Versioned<'_>

Wraps the object into a versioned enum with a variant for each version. This will use references on the underlying types if possible.

impl VersionizeOwned for CompactCiphertextList

where CompactCiphertextListVersions: VersionsDispatch<Self>,

type VersionedOwned = <CompactCiphertextListVersions as VersionsDispatch<CompactCiphertextList>>::Owned

fn versionize_owned(self) -> Self::VersionedOwned

Wraps the object into a versioned enum with a variant for each version. This will clone the underlying types.

impl VersionizeSlice for CompactCiphertextList

where CompactCiphertextListVersions: VersionsDispatch<Self>,

type VersionedSlice<'vers> = Vec<<CompactCiphertextList as Versionize>::Versioned<'vers>>

fn versionize_slice(slice: &[Self]) -> Self::VersionedSlice<'_>

impl VersionizeVec for CompactCiphertextList

where CompactCiphertextListVersions: VersionsDispatch<Self>,

type VersionedVec = Vec<<CompactCiphertextList as VersionizeOwned>::VersionedOwned>

fn versionize_vec(vec: Vec<Self>) -> Self::VersionedVec

impl VersionsDispatch<CompactCiphertextList> for CompactCiphertextListVersions

where CompactCiphertextListV0: Version + Upgrade<CompactCiphertextList>, CompactCiphertextList: Version,

type Ref<'vers> = CompactCiphertextListVersionsDispatch<'vers>

type Owned = CompactCiphertextListVersionsDispatchOwned