Struct TypedGeneration 

pub struct TypedGeneration<T: TypedGenerationKind> { /* private fields */ }

A generation number with type-level information about what it’s used for.

For more, see the library documentation.

Implementations

impl<T: TypedGenerationKind> TypedGeneration<T>

pub const ZERO: Self

The generation number before any change has been applied, 0.

Generation numbers conventionally start at 1 (see Self::new). Zero is reserved to represent an initial or empty state that precedes the first generation.

pub const MAX: Self

The largest possible generation number, 2**63 - 1.

pub const fn new() -> Self

Creates the first generation number of this type, which is 1.

There is deliberately no Default impl: whether a value should start at Self::ZERO or at the first generation is a choice callers must make explicitly.

pub const fn from_u32(value: u32) -> Self

Creates a generation number of this type from a u32.

Every u32 is a valid generation number, so this conversion is infallible.

pub const fn next(&self) -> Self

Returns the next generation number.

Panics

Panics if the next generation number would exceed Self::MAX. Use Self::checked_next to handle overflow instead.

pub const fn checked_next(&self) -> Option<Self>

Returns the next generation number, or None if it would exceed Self::MAX.

pub const fn prev(&self) -> Option<Self>

Returns the previous generation number, or None if this is the first generation.

Both 1 and Self::ZERO are treated as having no predecessor: prev never returns Self::ZERO.

pub const fn as_u64(self) -> u64

Returns the generation number as a u64.

pub const fn as_i64(self) -> i64

Returns the generation number as an i64.

This conversion is infallible because generation numbers are restricted to 2**63 - 1.

pub const fn upcast<U: TypedGenerationKind>(self) -> TypedGeneration<U>

where T: Into<U>,

Converts the generation number to one with looser semantics.

By default, generation kinds are considered independent, and conversions between them must happen via the GenericGeneration interface. But in some cases, there may be a relationship between two different generation kinds, and you may wish to easily convert generation numbers from one kind to another.

Typically, a conversion from TypedGeneration<T> to TypedGeneration<U> is most useful when T’s semantics are a superset of U’s, or in other words, when every TypedGeneration<T> is logically also a TypedGeneration<U>.

For instance:

• Imagine you have TypedGenerationKinds for different types of database connections, where DbConnKind is the general type and PgConnKind is a specific kind for Postgres.
• Since every Postgres connection is also a database connection, a cast from TypedGeneration<PgConnKind> to TypedGeneration<DbConnKind> makes sense.
• The inverse cast would not make sense, as a database connection may not necessarily be a Postgres connection.

This interface provides an alternative, safer way to perform this conversion. Indicate your intention to allow a conversion between kinds by implementing From<T> for U, as shown in the example below.

Examples

use oxide_generation::{TypedGeneration, TypedGenerationKind, TypedGenerationTag};

// Let's say that these generation numbers track repositories for
// different version control systems, such that you have a generic
// RepoKind:
pub enum RepoKind {}
impl TypedGenerationKind for RepoKind {
    const TAG: TypedGenerationTag = TypedGenerationTag::new("repo");
}

// You also have more specific kinds:
pub enum GitRepoKind {}
impl TypedGenerationKind for GitRepoKind {
    const TAG: TypedGenerationTag = TypedGenerationTag::new("git_repo");
}
// (and HgRepoKind, JujutsuRepoKind, etc...)

// First, define a `From` impl. This impl indicates your desire
// to convert from one kind to another.
impl From<GitRepoKind> for RepoKind {
    fn from(value: GitRepoKind) -> Self {
        match value {}
    }
}

// Now you can convert between them:
let git_generation: TypedGeneration<GitRepoKind> = TypedGeneration::from_u32(5);
let repo_generation: TypedGeneration<RepoKind> = git_generation.upcast();

Trait Implementations

impl<T> Arbitrary for TypedGeneration<T>

where T: TypedGenerationKind,

Available on crate feature proptest1 only.

Generates random TypedGeneration<T> instances.

Values are drawn uniformly from the range 0..=TypedGeneration::MAX.

type Parameters = TypedGenerationParams

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<TypedGeneration<T>>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl<T: TypedGenerationKind> Clone for TypedGeneration<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: TypedGenerationKind> Copy for TypedGeneration<T>

impl<T: TypedGenerationKind> Debug for TypedGeneration<T>

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

Formats the value using the given formatter.

impl<'de, T: TypedGenerationKind> Deserialize<'de> for TypedGeneration<T>

Available on crate feature serde only.

Deserializes a TypedGeneration<T> using the same format as Generation.

This impl does not require T to implement Deserialize.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: TypedGenerationKind> Diffable for TypedGeneration<T>

Available on crate feature daft01 only.

Diffs a TypedGeneration<T> as a leaf value.

This impl does not require T to implement Diffable.

type Diff<'daft> = Leaf<&'daft TypedGeneration<T>>

The type of the diff.

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

Compute the diff between two values.

impl<T: TypedGenerationKind> Display for TypedGeneration<T>

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

Formats the value using the given formatter.

impl<T: TypedGenerationKind> Eq for TypedGeneration<T>

impl<T: TypedGenerationKind> From<&TypedGeneration<T>> for i64

fn from(g: &TypedGeneration<T>) -> Self

Converts to this type from the input type.

impl<T: TypedGenerationKind> From<TypedGeneration<T>> for u64

fn from(g: TypedGeneration<T>) -> Self

Converts to this type from the input type.

impl<T: TypedGenerationKind> From<TypedGeneration<T>> for i64

fn from(g: TypedGeneration<T>) -> Self

Converts to this type from the input type.

impl<T: TypedGenerationKind> From<u32> for TypedGeneration<T>

fn from(value: u32) -> Self

Converts to this type from the input type.

impl<T: TypedGenerationKind> FromStr for TypedGeneration<T>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<T: TypedGenerationKind> GenericGeneration for TypedGeneration<T>

fn from_untyped_generation(generation: Generation) -> Self

Creates a new instance of Self from an untyped Generation.

fn into_untyped_generation(self) -> Generation

Converts self into an untyped Generation.

fn as_untyped_generation(&self) -> &Generation

Returns the inner Generation.

impl<T: TypedGenerationKind> Hash for TypedGeneration<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> JsonSchema for TypedGeneration<T>

where T: TypedGenerationKind + JsonSchema,

Available on crate feature schemars08 only.

Implements JsonSchema for TypedGeneration<T>, if T implements JsonSchema.

• schema_name is set to "TypedGenerationFor", concatenated by the schema name of T.
• schema_id is set to format!("oxide_generation::TypedGeneration<{}>", T::schema_id()).
• json_schema is the same as the one for Generation (including its description), with the x-rust-type extension to allow automatic replacement in typify and progenitor.

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl<T: TypedGenerationKind> Ord for TypedGeneration<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: TypedGenerationKind> PartialEq for TypedGeneration<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: TypedGenerationKind> PartialOrd for TypedGeneration<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: TypedGenerationKind> Serialize for TypedGeneration<T>

Available on crate feature serde only.

Serializes a TypedGeneration<T> using the same format as Generation.

This impl does not require T to implement Serialize.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: TypedGenerationKind> TryFrom<i64> for TypedGeneration<T>

type Error = GenerationNegativeError

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: TypedGenerationKind> TryFrom<u64> for TypedGeneration<T>

type Error = GenerationOverflowError

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: TypedGenerationKind> Value for TypedGeneration<T>

Available on crate feature slog2 only.

Logs a TypedGeneration<T> as an integer, using the same format as Generation.

This impl does not require T to implement slog::Value.

fn serialize( &self, _rec: &Record<'_>, key: Key, serializer: &mut dyn Serializer, ) -> Result

Serialize self into Serializer