Struct kube_runtime::reflector::ObjectRef

pub struct ObjectRef<K: Resource> {
    pub name: String,
    pub namespace: Option<String>,
    // some fields omitted
}

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

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"));

Implementations

impl<K: Resource> ObjectRef<K> where
    K::DynamicType: Default, 

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

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

impl<K: Resource> 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: Resource, 

Creates ObjectRef from the resource and dynamic type. Panics if name is missing (name always exists if the object was returned from the apiserver)

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: Resource>(
    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: Resource> 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: Resource> Debug for ObjectRef<K> where
    K::DynamicType: Debug, 

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<K: Resource> Hash for ObjectRef<K> where
    K::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, 

Feeds a slice of this type into the given Hasher.

impl<K: Resource> PartialEq<ObjectRef<K>> for ObjectRef<K> where
    K::DynamicType: PartialEq, 

fn eq(&self, other: &Self) -> 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 !=.

impl<K: Resource> Eq for ObjectRef<K> where
    K::DynamicType: Eq,