Struct kube::runtime::reflector::ObjectRef

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

Available on crate feature runtime only.

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 as Lookup>::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> ObjectRef<K>

where K: Lookup, <K as Lookup>::DynamicType: Default,

pub fn new(name: &str) -> ObjectRef<K>

pub fn from_obj(obj: &K) -> ObjectRef<K>

where K: Lookup,

impl<K> ObjectRef<K>

where K: Lookup,

pub fn new_with(name: &str, dyntype: <K as Lookup>::DynamicType) -> ObjectRef<K>

pub fn within(self, namespace: &str) -> ObjectRef<K>

pub fn from_obj_with( obj: &K, dyntype: <K as Lookup>::DynamicType ) -> ObjectRef<K>

where K: Lookup,

Creates ObjectRef from the resource and dynamic type.

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

Create an ObjectRef from an OwnerReference

Returns None if the types do not match.

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

where K2: Lookup,

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> Clone for ObjectRef<K>

where K: Lookup + ?Sized, <K as Lookup>::DynamicType: Clone,

fn clone(&self) -> ObjectRef<K>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K> Debug for ObjectRef<K>

where K: Lookup + ?Sized, <K as Lookup>::DynamicType: Debug,

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

Formats the value using the given formatter.

impl<K> Display for ObjectRef<K>

where K: Lookup,

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

Formats the value using the given formatter.

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

where K: Resource,

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

Converts to this type from the input type.

impl<K> Hash for ObjectRef<K>

where K: Lookup + ?Sized, <K as Lookup>::DynamicType: Hash,

fn hash<__HK>(&self, __state: &mut __HK)

where __HK: Hasher,

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> PartialEq for ObjectRef<K>

where K: Lookup + ?Sized, <K as Lookup>::DynamicType: PartialEq,

fn eq(&self, other: &ObjectRef<K>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<K> Eq for ObjectRef<K>

where K: Lookup + ?Sized, <K as Lookup>::DynamicType: Eq,