struct

ReferenceStorage(T)

ReferenceStorage(T) provides the minimum storage for the instance data of an object of type T. The compiler guarantees that sizeof(ReferenceStorage(T)) == instance_sizeof(T) and alignof(ReferenceStorage(T)) == instance_alignof(T) always hold, which means Pointer(ReferenceStorage(T)) and T are binary-compatible.

T must be a non-union reference type.

WARNING: ReferenceStorage is only necessary for manual memory management, such as creating instances of T with a non-default allocator. Therefore, this type is unsafe and no public constructors are defined.

WARNING: ReferenceStorage is unsuitable when instances of T require more than instance_sizeof(T) bytes, such as String and Log::Metadata.

Instance methods

==(other : ReferenceStorage(T)) : Bool

Returns whether self and other are bytewise equal.

NOTE: This does not call T#==, so it works even if self or other does not represent a valid instance of T. If validity is guaranteed, call to_reference == other.to_reference instead to use T#==.

Source

==(other) : Bool

Returns false.

Source

hash(hasher)

Appends this object's value to hasher, and returns the modified hasher.

Usually the macro def_hash can be used to generate this method. Otherwise, invoke hash(hasher) on each object's instance variables to accumulate the result:

def hash(hasher)
  hasher = @some_ivar.hash(hasher)
  hasher = @some_other_ivar.hash(hasher)
  hasher
end

Source

to_reference

Returns a T whose instance data refers to self.

WARNING: The caller is responsible for ensuring that the instance data is correctly initialized and outlives the returned T.

Source

to_s(io : IO) : Nil

Prints a nicely readable and concise string representation of this object, typically intended for users, to io.

This method is called when an object is interpolated in a string literal:

"foo #{bar} baz" # calls bar.to_io with the builder for this string

IO#<< calls this method to append an object to itself:

io << bar # calls bar.to_s(io)

Thus implementations must not interpolate self in a string literal or call io << self which both would lead to an endless loop.

Also see #inspect(IO).

Source