Struct PublicSeq

pub struct PublicSeq<T: Default + PublicInteger> { /* private fields */ }

Variable length byte arrays.

Implementations

impl PublicSeq<u8>

pub fn from_public_slice(v: &[u8]) -> PublicSeq<u8>

pub fn from_native(b: Vec<u8>) -> PublicSeq<u8>

pub fn to_native(&self) -> Vec<u8>

pub fn into_native(self) -> Vec<u8>

pub fn as_slice(&self) -> &[u8]

impl<T: Clone + Default + PublicInteger> PublicSeq<T>

pub fn new(l: usize) -> Self

pub fn with_capacity(l: usize) -> Self

pub fn reserve(self, additional: usize) -> Self

pub fn len(&self) -> usize

Get the size of this sequence.

pub fn slice(&self, start_out: usize, len: usize) -> Self

pub fn native_slice(&self) -> &[T]

pub fn into_slice(self, start_out: usize, len: usize) -> Self

pub fn slice_range(&self, r: Range<usize>) -> Self

pub fn into_slice_range(self, r: Range<usize>) -> Self

pub fn split_off(self, at: usize) -> (Self, Self)

pub fn pop(self) -> (T, Self)

pub fn truncate(self, len: usize) -> Self

pub fn from_slice<A: SeqTrait<T>>(input: &A, start: usize, len: usize) -> Self

pub fn concat<A: SeqTrait<T>>(&self, next: &A) -> Self

pub fn concat_owned(self, next: Self) -> Self

pub fn push(&self, next: &T) -> Self

pub fn push_owned(self, next: T) -> Self

pub fn from_slice_range<A: SeqTrait<T>>(input: &A, r: Range<usize>) -> Self

pub fn num_chunks(&self, chunk_size: usize) -> usize

pub fn num_exact_chunks(&self, chunk_size: usize) -> usize

Get the number of chunks of chunk_size in this array. There might be less than chunk_size remaining elements in this array beyond these.

pub fn get_chunk(&self, chunk_size: usize, chunk_number: usize) -> (usize, Self)

pub fn get_exact_chunk(&self, chunk_size: usize, chunk_number: usize) -> Self

Get the chunk_number chunk of chunk_size from this array as Seq<T>. The resulting sequence is of exactly chunk_size length. Until #84 is fixed this returns an empty sequence if not enough elements are left.

pub fn get_remainder_chunk(&self, chunk_size: usize) -> Self

Get the remaining chunk of this array of length less than chunk_size. If there’s no remainder, i.e. if the length of this array can be divided by chunk_size without a remainder, the function returns an empty sequence (until #84 is fixed).

pub fn set_chunk<A: SeqTrait<T>>( self, chunk_size: usize, chunk_number: usize, input: &A, ) -> Self

pub fn set_exact_chunk<A: SeqTrait<T>>( self, chunk_size: usize, chunk_number: usize, input: &A, ) -> Self

pub fn update_owned(self, start_out: usize, v: Self) -> Self

impl<T: Clone + Default + PublicInteger> PublicSeq<T>

pub fn from_vec(b: Vec<T>) -> PublicSeq<T>

pub fn from_native_slice(x: &[T]) -> PublicSeq<T>

pub fn from_seq<U: SeqTrait<T>>(x: &U) -> PublicSeq<T>

impl PublicSeq<u8>

pub fn from_hex(s: &str) -> PublicSeq<u8>

pub fn from_string(s: String) -> PublicSeq<u8>

impl PublicSeq<u8>

pub fn to_hex(&self) -> String

Trait Implementations

impl<T: Numeric + PublicInteger + Copy> Add for PublicSeq<T>

Polynomial addition on ℤ[x]

type Output = PublicSeq<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Numeric + PublicInteger + Copy> BitAnd for PublicSeq<T>

type Output = PublicSeq<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T: Numeric + PublicInteger + Copy> BitOr for PublicSeq<T>

type Output = PublicSeq<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T: Numeric + PublicInteger + Copy> BitXor for PublicSeq<T>

type Output = PublicSeq<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T: Clone + Default + PublicInteger> Clone for PublicSeq<T>

fn clone(&self) -> PublicSeq<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Default + PublicInteger> Debug for PublicSeq<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default + Default + PublicInteger> Default for PublicSeq<T>

fn default() -> PublicSeq<T>

Returns the “default value” for a type.

impl<T: Clone + Default + PublicInteger> Index<Range<usize>> for PublicSeq<T>

type Output = [T]

The returned type after indexing.

fn index(&self, r: Range<usize>) -> &[T]

Performs the indexing (container[index]) operation.

impl<T: Clone + Default + PublicInteger> Index<i32> for PublicSeq<T>

type Output = T

The returned type after indexing.

fn index(&self, i: i32) -> &T

Performs the indexing (container[index]) operation.

impl<T: Clone + Default + PublicInteger> Index<u32> for PublicSeq<T>

type Output = T

The returned type after indexing.

fn index(&self, i: u32) -> &T

Performs the indexing (container[index]) operation.

impl<T: Clone + Default + PublicInteger> Index<u8> for PublicSeq<T>

type Output = T

The returned type after indexing.

fn index(&self, i: u8) -> &T

Performs the indexing (container[index]) operation.

impl<T: Clone + Default + PublicInteger> Index<usize> for PublicSeq<T>

type Output = T

The returned type after indexing.

fn index(&self, i: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T: Clone + Default + PublicInteger> IndexMut<i32> for PublicSeq<T>

fn index_mut(&mut self, i: i32) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T: Clone + Default + PublicInteger> IndexMut<u32> for PublicSeq<T>

fn index_mut(&mut self, i: u32) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T: Clone + Default + PublicInteger> IndexMut<u8> for PublicSeq<T>

fn index_mut(&mut self, i: u8) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T: Clone + Default + PublicInteger> IndexMut<usize> for PublicSeq<T>

fn index_mut(&mut self, i: usize) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T: Numeric + PublicInteger + Copy> ModNumeric for PublicSeq<T>

fn sub_mod(self, rhs: Self, n: Self) -> Self

(self - rhs) % n.

fn add_mod(self, rhs: Self, n: Self) -> Self

(self + rhs) % n

fn mul_mod(self, rhs: Self, n: Self) -> Self

(self * rhs) % n

fn pow_mod(self, exp: Self, n: Self) -> Self

(self ^ exp) % n

fn modulo(self, n: Self) -> Self

self % n

fn absolute(self) -> Self

|self| (coefficient-wise)

fn signed_modulo(self, _n: Self) -> Self

self % n that always returns a positive integer

impl<T: Numeric + PublicInteger + Copy> Mul for PublicSeq<T>

Polynomial multiplication on ℤ[x]

type Output = PublicSeq<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T: Numeric + PublicInteger + Copy> Not for PublicSeq<T>

type Output = PublicSeq<T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: Numeric + PublicInteger + Copy> Numeric for PublicSeq<T>

fn max_val() -> Self

Return largest value that can be represented.

fn exp(self, exp: u32) -> Self

self ^ exp where exp is a u32.

fn pow_self(self, exp: Self) -> Self

self ^ exp where exp is a Self.

fn divide(self, rhs: Self) -> Self

Division.

fn inv(self, n: Self) -> Self

Invert self modulo n.

fn wrap_add(self, rhs: Self) -> Self

fn wrap_sub(self, rhs: Self) -> Self

fn wrap_mul(self, rhs: Self) -> Self

fn wrap_div(self, rhs: Self) -> Self

fn equal(self, other: Self) -> bool

fn greater_than(self, other: Self) -> bool

fn greater_than_or_equal(self, other: Self) -> bool

fn less_than(self, other: Self) -> bool

fn less_than_or_equal(self, other: Self) -> bool

fn not_equal_bm(self, other: Self) -> Self

fn equal_bm(self, other: Self) -> Self

fn greater_than_bm(self, other: Self) -> Self

fn greater_than_or_equal_bm(self, other: Self) -> Self

fn less_than_bm(self, other: Self) -> Self

fn less_than_or_equal_bm(self, other: Self) -> Self

impl<T: Copy + Default + PartialEq + PublicInteger> PartialEq for PublicSeq<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Clone + Default + PublicInteger> SeqTrait<T> for PublicSeq<T>

fn create(l: usize) -> Self

Get a new sequence of capacity l.

fn len(&self) -> usize

fn iter(&self) -> Iter<'_, T>

fn update_slice<A: SeqTrait<T>>( self, start_out: usize, v: &A, start_in: usize, len: usize, ) -> Self

Update this sequence with l elements of v, starting at start_in, at start_out.

fn update<A: SeqTrait<T>>(self, start: usize, v: &A) -> Self

Update this sequence with v starting at start.

fn update_start<A: SeqTrait<T>>(self, v: &A) -> Self

impl<T: Numeric + PublicInteger + Copy> Shl<usize> for PublicSeq<T>

type Output = PublicSeq<T>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation.

impl<T: Numeric + PublicInteger + Copy> Shr<usize> for PublicSeq<T>

type Output = PublicSeq<T>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation.

impl<T: Numeric + PublicInteger + Copy> Sub for PublicSeq<T>

Polynomial subtraction on ℤ[x]

type Output = PublicSeq<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: Copy + Default + PartialEq + PublicInteger> Eq for PublicSeq<T>