Struct ImageRef 

pub struct ImageRef { /* private fields */ }

Image reference that preserves the user’s RAW input string alongside the parsed canonical ImageReference.

ImageReference (from oci_client) normalizes Docker Hub defaults at parse time — nginx becomes docker.io/library/nginx. That’s correct for resolution, but destroys the ability to detect “the user wrote a bare name and we should look for it locally first.”

ImageRef holds both:

• parsed: the canonical ImageReference for normalized comparisons, registry calls, and tag/digest extraction.
• original: the exact bytes the user (or wire format) gave us.

Equality and hashing use the canonical parsed form, so two ImageRefs resolving to the same image compare equal even if one was qualified. Display / Serialize use the original, so roundtripping preserves what the user typed.

Implementations

impl ImageRef

pub fn from_parsed(parsed: ImageReference) -> Self

Wrap an already-parsed ImageReference. The original field is set to the canonical string form, so Self::is_unqualified on the result will return false (the canonical form always has a host).

pub fn parsed(&self) -> &ImageReference

Access the parsed canonical ImageReference.

pub fn original(&self) -> &str

Access the user’s original input string verbatim.

pub fn is_unqualified(&self) -> bool

Returns true when the user’s original string did NOT include a registry host (no host[:port]/ prefix). Detection rule: split on the FIRST /; if there’s no / at all, or the segment before the first / contains neither . nor : and is not localhost, treat as unqualified.

Examples:

• nginx -> unqualified
• nginx:latest -> unqualified
• library/nginx -> unqualified (Docker namespace, no host)
• foo/bar -> unqualified
• docker.io/library/nginx -> qualified (host has .)
• ghcr.io/foo/bar -> qualified (host has .)
• localhost/foo -> qualified (literal localhost)
• localhost:5000/foo -> qualified (: port)
• registry:5000/foo -> qualified (: port)

Methods from Deref<Target = ImageReference>

pub fn clone_with_digest(&self, digest: String) -> Reference

Clone the Reference for the same image with a new digest.

pub fn resolve_registry(&self) -> &str

Resolve the registry address of a given Reference.

Some registries, such as docker.io, uses a different address for the actual registry. This function implements such redirection.

If a mirror registry is set, it will be used instead of the original registry.

pub fn registry(&self) -> &str

Returns the name of the registry.

pub fn repository(&self) -> &str

Returns the name of the repository.

pub fn tag(&self) -> Option<&str>

Returns the object’s tag, if present.

pub fn digest(&self) -> Option<&str>

Returns the object’s digest, if present.

pub fn whole(&self) -> String

Returns the whole reference.

Trait Implementations

impl Clone for ImageRef

fn clone(&self) -> ImageRef

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ImageRef

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for ImageRef

type Target = Reference

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for ImageRef

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for ImageRef

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for ImageRef

impl FromStr for ImageRef

type Err = <Reference as FromStr>::Err

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for ImageRef

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ImageRef

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ImageRef

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.