Crate scsys 

scsys

---

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

cont

this module implements a set of traits and utilities for working with containers this module is focused on defining a set of traits and types for abstracting the behaviourds of an entity capable of storing some data.

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 This module focuses on the Id implementation, a generic wrapper type used to define various identifiers. The Id type is equipped with additional methods and traits to facilitate the creation and management of identifiers in a type-safe manner.

rand

Utilities for random number generation

rand_distr

Generating random samples from probability distributions.

state

The state module provides various abstractions and implementations for working with states within Rust.

time

The time module focuses on implementing various time-related features and utilities. It provides a generic Timestamp along with supporting traits and types to facilitate time management.

traits

this module contains various traits commonly used throughout the scsys ecosystem

types

utils

utilities for working with the scsys ecosystem

Macros

fmt_wrapperDeprecated

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

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

Timestamp

Timestamp is a generic implementation of a type that represents some point in time.

Enums

Error

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

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.

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.

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

The IsType trait provides a method to check if the current type is of a specific type at runtime. This is useful for dynamic type checking in scenarios where the type may not be known at compile time.

Named

Interface for nameable data-structures

Now

The Now trait provides a common creation routines for all datetime implementations.

RawTimestamp

A marker trait indicating types capable of representing a raw timestamp value.

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.

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

The TypeOf trait automatically provides a way to check if a type is of a specific type at compile time. This is useful for generic programming and type checking.

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

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 that uses the custom Error type

Derive Macros

Display

the Display macro automatically implements the Display trait for a struct or enum, using the scsys attributes to customize the output.

Get

GetMut

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