Expand description
Import Structure Doctrine:
The purpose is to let us define our conventional namespace once,
without causing failures due to ambiguity. (Importing the same name
via different import paths, both with *, does not work - the name is
regarded as ambiguous even though the referet is the same. And the
error messages are hopeless: when this occurs the * imports are
simply ineffective for that name and nothing tells you there’s an
ambiguity.)
Each crate has these (public) modules:
-
crates: Onepub usestatement for each dependency crate, including the otter crates, providing simply the crate name. -
imports:pub usestatements for the names within crates that this crate wants to use, excluding any that are in theimportsof this crate’s dependencies. This mayusevariouscrates::*or evenimports::*but must notpub use. -
prelude: Brings all the parts together for the use of this crate. Shouldpub usethecrates::*andimports::*for this crate and the dependencies. Should not be used elsewhere.
Re-exports
Modules
arrayvec provides the types ArrayVec and ArrayString:
array-backed vector and string types, which store their contents inline.
An ordered map based on a B-Tree.
An ordered set based on a B-Tree.
Chrono: Date and Time for Rust
Chrono-TZ 0.4.1
Functionality for ordering and comparison.
derive_more
This crate provides traits which describe functionality of cryptographic hash functions and Message Authentication algorithms.
Educe
Inspection and manipulation of the process’s environment.
Create extensions for types you don’t own with extension traits but without the boilerplate.
A flexible and easy-to-use logger that writes logs to stderr and/or to files or other output streams.
Utilities for formatting and printing Strings.
Filesystem manipulation operations.
Extended utilities for working with files and filesystems in Rust.
A hash map implemented with quadratic probing and SIMD lookup.
This crate provides a single macro called if_chain!.
Traits, helpers, and type definitions for core I/O functionality.
Composable external iteration.
Extra iterator adaptors, functions and macros.
A macro for declaring lazily evaluated statics.
A lightweight logging facade.
Basic functions for dealing with memory.
Rust friendly bindings to the various *nix system functions.
Procedural macros to derive numeric traits in Rust.
Otter game system (part thereeof)
This library provides implementations of Mutex, RwLock, Condvar and
Once that are smaller, faster and more flexible than those in the Rust
standard library. It also provides a ReentrantMutex type.
Safe interface to <pwd.h>
Utilities for random number generation
This crate connects Rust MessagePack library with serde providing an ability to
easily serialize and deserialize both Rust built-in types, the standard library and custom data
structures.
Serde
Serde JSON
slotmap
Unicode string slices.
Temporal quantification.
Determine displayed width of char and str types according to
Unicode Standard Annex #11
rules.
Safe wrappers around functions found in libc “unistd.h” header
Platform-specific extensions to std for Unix platforms.
Void
Macros
Derive macro generating an impl of the trait Debug.
Derive macro generating an impl of the trait Hash.
Construct an ad-hoc error from a string or existing non-anyhow error
value.
Logs a message at the debug level.
Inspects an environment variable at compile time.
Logs a message at the error level.
Macro for writing nested if let expressions.
Logs a message at the info level.
Create an iterator over the “cartesian product” of iterators.
Create an iterator running multiple iterators in lockstep.
The standard logging macro.
Determines if a message logged at the specified level in that module will be logged.
Throw an error.
Logs a message at the trace level.
Logs a message at the warn level.
Structs
Sample a u8, uniformly distributed over ASCII letters and numbers:
a-z, A-Z and 0-9.
A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically Reference Counted’.
A vector with a fixed capacity.
An ordered set based on a B-Tree.
The BufReader<R> struct adds buffering to any reader.
Wraps a writer and buffers its output.
Representation of a running or exited child process.
A process builder, providing fine-grained control over how a new process should be spawned.
Dense slot map, storage with stable unique keys.
A Duration type to represent a span of time, typically used for system
timeouts.
A reference to an open file on the filesystem.
Configuration for formatting.
An IPv4 address.
An IPv6 address.
Immutable struct that defines which loglines are to be written, based on the module, the log level, and the text.
Zero-sized type used to mark things that “act like” they own a T.
Sparse secondary map, associate data with previously stored elements in a slot map.
The error type returned when a checked integral type conversion fails.
User identifier
A Unix stream socket.
A double-ended queue implemented with a growable ring buffer.
Provides intentionally-wrapped arithmetic on T.
Enums
Defines big-endian serialization.
A clone-on-write smart pointer.
Value that either holds a single A or B, or both.
A list specifying general categories of I/O error.
An IP address, either IPv4 or IPv6.
Defines little-endian serialization.
An Ordering is the result of a comparison between two values.
An internet socket address, either IPv4 or IPv6.
The empty type for cases which can’t occur.
Constants
The full circle constant (τ)
Traits
A trait to extract the raw file descriptor from an underlying object.
A trait for borrowing data.
Numbers which have upper and lower bounds
A BufRead is a type of Reader which has an internal buffer, allowing it
to perform extra ways of reading.
Unix-specific extensions to the process::Command builder.
Provides the context method for Result.
? formatting.
Used for immutable dereferencing operations, like *v.
Used for mutable dereferencing operations, like in *v = 1;.
A data structure that can be deserialized from any data format supported by Serde.
A data structure that can be deserialized without borrowing any data from the deserializer.
A data format that can deserialize any data structure supported by Serde.
Convinience wrapper trait covering functionality of cryptographic hash functions with fixed output size.
Format trait for an empty format, {}.
A trait for capturing the number of variants in Enum. This trait can be autoderived by
strum_macros.
Associates additional pieces of information with an Enum. This can be
autoimplemented by deriving EnumMessage and annotating your variants with
#[strum(message="...")].
EnumProperty is a trait that makes it possible to store additional information
with enum variants. This trait is designed to be used with the macro of the same
name in the strum_macros crate. Currently, the only string literals are supported
in attributes, the other methods will be implemented as additional attribute types
become stabilized.
Unix-specific extensions to process::ExitStatus and
ExitStatusError.
Extension trait for std::fs::File which provides allocation, duplication and locking methods.
A generic trait for converting a number to a value.
Parse a value from a string
An iterator that always continues to yield None when exhausted.
A hashable type.
A trait for hashing an arbitrary stream of bytes.
Used for indexing operations (container[index]) in immutable contexts.
Used for indexing operations (container[index]) in mutable contexts.
This trait designates that an Enum can be iterated over. It can
be auto generated using strum_macros on your behalf.
A trait to express the ability to consume an object and acquire ownership of its raw file descriptor.
Extension trait for slotmap::KeyData, providing get_idx_version.
Unix-specific extensions to fs::Metadata.
Unix-specific extensions to fs::OpenOptions.
Unix-specific extensions to fs::Permissions.
The Read trait allows for reading bytes from a source.
Extends Read with methods for reading numbers. (For std::io.)
An automatically-implemented extension trait on RngCore providing high-level
generic methods for sampling values and other convenience methods.
A data structure that can be serialized into any data format supported by Serde.
Returned from Serializer::serialize_tuple.
A data format that can serialize any data structure supported by Serde.
Extension trait on slices, providing random mutation and sampling methods.
A generic trait for converting a value to a number.
A trait for objects which can be converted or resolved to one or more
SocketAddr values.
Simple and safe type conversions that may fail in a controlled
way under some circumstances. It is the reciprocal of TryInto.
An attempted conversion that consumes self, which may or may not be
expensive.
A trait for objects which are byte-oriented sinks.
Extends Write with methods for writing numbers. (For std::io.)
A trait for writing or formatting into Unicode-accepting buffers or streams.
OS-specific extensions to fs::Metadata.
The Error trait allows Deserialize implementations to create descriptive
error messages belonging to the Deserializer against which they are
currently running.
Key used to access stored values in a slot map.
Functions
Cast from one machine scalar to another.
Create an iterator that first iterates i and then j.
Get the time of the specified clock, (see clock_gettime(2)).
Terminates the current process with the specified exit code.
Underlying extraction function. Fails rather than panicing.
Compares and returns the maximum of two values.
Compares and returns the minimum of two values.
Retrieve the lazily-initialized thread-local random number generator,
seeded by the system. Intended to be used in method chaining style,
e.g. thread_rng().gen::<i32>(), or cached locally, e.g.
let mut rng = thread_rng();. Invoked by the Default trait, making
ThreadRng::default() equivalent.
Iterate i and j in lock step.
Type Definitions
A mutual exclusion primitive useful for protecting shared data
An RAII implementation of a “scoped lock” of a mutex. When this structure is dropped (falls out of scope), the lock will be unlocked.
Raw file descriptors.
A reader-writer lock
RAII structure used to release the shared read access of a lock when dropped.
RAII structure used to release the exclusive write access of a lock when dropped.
SHA-512 hasher.
SHA-512/256 hasher.
Attribute Macros
Derive Macros
Converts enum variants to &'static str.
Deserialize value by using its FromStr implementation
Add a constant usize equal to the number of variants.
Generate a new type with only the discriminant names.
Creates a new type that iterates of the variants of an enum.
Add a verbose message to an enum variant.
Add custom properties to enum variants.
Converts strings to enum variants based on their name.
Derives num_traits::FromPrimitive for simple enums and newtypes.
Implements From<MyEnum> for &'static str on an enum.
Serialize value by using it’s Display implementation
Derives num_traits::ToPrimitive for simple enums and newtypes.