Crate scsys

Source
Expand description

§scsys

crates.io docs.rs GitHub License


Welcome to scsys, this crate is tasked with providing a generic set of tools for the scsys.io ecosystem. It is designed to be a foundational library that helps establish a sense of consistency between individual efforts while working to reduce its overall footprint through modularization and feature-gating. These characteristics make it suitable for use both within the ecosystem and outside of it.

Modules§

config
the config module implements a set of standardized configuration schemas A collection of common configuration primitives and utilities used throughout the scsys-io ecosystem.
crypto
cryptographic primitives and utilities implemented for the ecosystem cryptographic primitives and utilities for the scsys ecosystem.
error
this module implements various error-handling primitives and utilities ths module implements various error-handling primitives and utilities
id
this module defines the generic Id wrapper and its implementations
prelude
rand
Utilities for random number generation
rand_distr
Generating random samples from probability distributions.
state
this module provides a set of states for state-related workloads (State & NState) this module implements a generic State wrapper and provides several traits to support state management and other stateful workloads.
time
a temporal module establishing a core set of time-related primitives and utilities such as Timestamp
traits
this module contains various traits commonly used throughout the scsys ecosystem
types
utils
utilities for working with the scsys ecosystem

Macros§

fmt_wrapper
Example
get_field
getter
A procedural macro for generativly creating getter methods; i.e. $field_name() -> &$field_type and $field_name_mut() -> &mut $field_type
gsw
The gsw macro generates getter and setter methods for the fields of a struct. At the moment, the macro can handle any type; for types that implement the Copy trait, simply drop the & to the left of each type.
wrapper

Structs§

ErrorBase
Id
Id is a generic identifier type that wraps a value of type T.
LinearDirectionIter
An iterator over the variants of LinearDirection
StageIter
An iterator over the variants of Stage
State
State is generic over some type Q that implements the RawState trait.
StateBase
StateBase is an abstract object that allows a particular kind of state to be associated with some generic state Q
StdError
The StdError type is a generic error type that is generic over the error kind; this enables us to distinguish between distinctly different error types.
Timestamp
Timestamp is a generic implementation of a type that represents some point in time.

Enums§

CoreError
EventStage
An EventStage is a generic enumeration that represents the three stages of an event in a system, allowing for the association of a type T with each stage. The stages are:
LinearDirection
The LinearDirection implementation enumerates the three pssoible movements in one-dimensional space, namely:
Stage
Auto-generated discriminant enum variants

Traits§

Appellation
Appellation defines a common interface for establishing a solid name for various entities.
Apply
Apply is a trait that allows for mapping over a reference to a type T by applying a function F to it, producing a new type U. The result is wrapped in a container type defined by the implementor of the trait.
ApplyMut
The ApplyMut trait allows for in-place mapping of a mutable reference to a type T
ApplyOnce
A the ApplyOnce trait is similar to [Map], but it consumes the instance instead of borrowing it;
AsSlice
AsSlice is a generic trait for converting a type into a slice of its elements. This is useful for types that can be represented as a contiguous sequence of elements, such as arrays, vectors, or other collections.
AsSliceMut
AsSliceMut is a generic trait for converting a type into a mutable slice of its elements.
Container
The Container trait is a higher-level abstraction over RawContainer.
DType
DType is a trait designed to provide additional information regarding the type of a particular value.
Decrement
Decrement defines an interface for decrementing a value.
DecrementMut
DecrementMut is a trait describing the ability to decrement a value in place. It is similar to Decrement, but it allows for mutable access to the value.
DecrementRef
DecrementRef is a trait describing the ability to decrement a value by reference.
Displayable
Displayable simply combines the two major traits core::fmt::Debug and core::fmt::Display into a single trait. This is useful for types that need to be displayed in a human-readable format, such as in debugging or logging.
ErrorKind
this trait is used to denote various error kinds for use throughout the sdk
Functor
The Functor trait extends the HKT trait to provide a way to map over its content(s) using a function f that transforms values of type T into values of type U.
Get
Get defines an interface for entities that can be accessed by a key; the design is similar to the Index trait in the standard library, however, uses the Borrow trait to allow for more flexible key types.
GetMut
GetMut defines an interface for entities that can be accessed by a key; the design is similar to the IndexMut trait in the standard library
HKT
The HKT trait defines an interface for higher-kinded types (HKT).
Increment
Increment defines an interface for incrementing a value.
IncrementMut
IncrementMut is similar to Increment, but it allows for incrementing a value in place.
IncrementRef
IncrementRef is similar to Increment, but it allows for incrementing a value by reference.
IntoInner
IntoInner is typically used for basic structures that wrap a single value.
IsType
KeyedContainer
Named
Interface for nameable data-structures
Now
The Now trait provides a common creation routines for all datetime implementations.
RawContainer
RawContainer defines a standard interface for all containers that are used to store other entities.
RawTimestamp
a private trait used to mark types capable of being uses as a basetype for a Timestamp.
RawWrapper
A RawWrapper is the base trait defining all so-called “wrapper” types.
RemoveFnl
This trait defines a method for removing the first and last entries within an entity.
StateRepr
The StateRepr trait defines the base type for stateful items, allowing for a generic item type to be associated with the state.
Stateful
Stateful is a trait establishing a common interface for all types that are state-aware.
Store
StringFmt
StringFmt is a trait that provides methods for formatting strings. Note This crate requires the alloc feature
Symbolic
Symbolic denotes a type consisting of some single or set of value(s) that can are considered displayable. Essentially, this trait is a wrapper around the Displayable trait enabling additional implementations
TypeOf
TypeTag
Typically, TypeTag is used for uninitaliziable enums with no variants
Wrapper
The Wrapper trait is used to establish a common interface for all simplemented structures that “wrap” a single value. Essentially, any type capable of implementing #[repr(transparent)] can be considered a wrapper.

Type Aliases§

BoxErr
A type alias for a Err whose generic type is a Box of a trait object implementing core::error::Error.
BoxError
Type alias for a boxed error with send, sync, and static flags enabled
BoxResult
Type alias for the standard result used
NState
A type alias for a StateBase equipped with a Nary kind of state
Result
a type alias for a Result type pre-configured with the [Error] type

Derive Macros§

Display
Getter
Set
VariantConstructors
This macro automatically generates functional constructors for all enclosed variants.
With
Wrapper
The Wrapper macro is designed for single-field structs, implementing additional methods supporting interactions with the inner value