Expand description

Fork of Arc for Servo. This has the following advantages over std::sync::Arc:

  • We don’t waste storage on the weak reference count.
  • We don’t do extra RMU operations to handle the possibility of weak references.
  • We can experiment with arena allocation (todo).
  • We can add methods to support our custom use cases 1.
  • We have support for dynamically-sized types (see from_header_and_iter).
  • We have support for thin arcs to unsized types (see ThinArc).
  • We have support for references to static data, which don’t do any refcounting.

Structs

An atomically reference counted shared pointer

A “borrowed Arc”. This is a pointer to a T that is known to have been allocated within an Arc.

ArcInner 🔒

The object allocated by an Arc

A tagged union that can represent Arc<A> or Arc<B> while only consuming a single word. The type is also NonNull, and thus can be stored in an Option without increasing size.

Structure to allow Arc-managing some fixed-sized data and a variably-sized slice in a single allocation.

Header data with an inline length. Consumers that use HeaderWithLength as the Header type in HeaderSlice can take advantage of ThinArc.

An Arc, except it holds a pointer to the T instead of to the entire ArcInner. This struct is FFI-compatible.

A “thin” Arc containing dynamically sized data

An Arc that is known to be uniquely owned

Enums

This represents a borrow of an ArcUnion.

Constants

A soft limit on the amount of references that may be made to an Arc.

Special refcount value that means the data is not reference counted, and that the Arc is really acting as a read-only static reference.

Functions

Computes the offset of the data field within ArcInner.

Type Definitions