Struct ObjectRef

#[non_exhaustive]
pub struct ObjectRef<K: Lookup + ?Sized> {
    pub dyntype: K::DynamicType,
    pub name: String,
    pub namespace: Option<String>,
    pub extra: Extra,
}

A typed and namedspaced (if relevant) reference to a Kubernetes object

K may be either the object type or DynamicObject, in which case the type is stored at runtime. Erased ObjectRefs pointing to different types are still considered different.

use kube_runtime::reflector::ObjectRef;
use k8s_openapi::api::core::v1::{ConfigMap, Secret};
assert_ne!(
    ObjectRef::<ConfigMap>::new("a").erase(),
    ObjectRef::<Secret>::new("a").erase(),
);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

dyntype: K::DynamicType

name: String

The name of the object

namespace: Option<String>

The namespace of the object

May only be None if the kind is cluster-scoped (not located in a namespace). Note that it is acceptable for an ObjectRef to a cluster-scoped resource to have a namespace. These are, however, not considered equal:

assert_ne!(ObjectRef::<ConfigMap>::new("foo"), ObjectRef::new("foo").within("bar"));

extra: Extra

Extra information about the object being referred to

This is not considered when comparing objects, but may be used when converting to and from other representations, such as OwnerReference or ObjectReference.

Implementations

impl<K: Lookup> ObjectRef<K>

where K::DynamicType: Default,

pub fn new(name: &str) -> Self

pub fn from_obj(obj: &K) -> Self

impl<K: Lookup> ObjectRef<K>

pub fn new_with(name: &str, dyntype: K::DynamicType) -> Self

pub fn within(self, namespace: &str) -> Self

pub fn from_obj_with(obj: &K, dyntype: K::DynamicType) -> Self

where K: Lookup,

Creates ObjectRef from the resource and dynamic type.

pub fn from_owner_ref( namespace: Option<&str>, owner: &OwnerReference, dyntype: K::DynamicType, ) -> Option<Self>

Create an ObjectRef from an OwnerReference

Returns None if the types do not match.

pub fn into_kind_unchecked<K2: Lookup>( self, dt2: K2::DynamicType, ) -> ObjectRef<K2>

Convert into a reference to K2

Note that no checking is done on whether this conversion makes sense. For example, every Service has a corresponding Endpoints, but it wouldn’t make sense to convert a Pod into a Deployment.

pub fn erase(self) -> ObjectRef<DynamicObject>

Trait Implementations

impl<K: Lookup + ?Sized> Clone for ObjectRef<K>

where K::DynamicType: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Lookup + ?Sized> Debug for ObjectRef<K>

where K::DynamicType: Debug,

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

Formats the value using the given formatter.

impl<K: Lookup> Display for ObjectRef<K>

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

Formats the value using the given formatter.

impl<K: Lookup> From<&K> for ObjectRef<K>

where K::DynamicType: Default,

fn from(obj: &K) -> Self

Converts to this type from the input type.

impl<K: Lookup> From<ObjectRef<K>> for ObjectReference

fn from(val: ObjectRef<K>) -> Self

Converts to this type from the input type.

impl<K: Resource> From<ObjectRef<K>> for ReconcileRequest<K>

fn from(obj_ref: ObjectRef<K>) -> Self

Converts to this type from the input type.

impl<K: Lookup + ?Sized> Hash for ObjectRef<K>

where K::DynamicType: Hash,

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<K: Lookup + ?Sized> PartialEq for ObjectRef<K>

where K::DynamicType: PartialEq,

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<K: Lookup + ?Sized> Eq for ObjectRef<K>

where K::DynamicType: Eq,