Struct DynCasedRecord 

pub struct DynCasedRecord<R> { /* private fields */ }

A wrapper around Record that affects whether key comparisons are case sensitive or not.

Implements commonly used methods of Record.

Implementations

impl<'a> DynCasedRecord<&'a Record>

pub fn index_of(self, col: impl AsRef<str>) -> Option<usize>

pub fn contains(self, col: impl AsRef<str>) -> bool

pub fn get(self, col: impl AsRef<str>) -> Option<&'a Value>

impl<'a> DynCasedRecord<&'a mut Record>

pub fn reborrow(&self) -> DynCasedRecord<&Record>

Explicit reborrowing. See Self::reborrow_mut()

pub fn reborrow_mut(&mut self) -> DynCasedRecord<&mut Record>

Explicit reborrowing. Using this before methods that receive self is necessary to avoid consuming the DynCasedRecord instance.

use nu_protocol::{record, record::{Record, DynCasedRecord}, Value, casing::Casing};

let mut rec = record!{
    "A" => Value::test_nothing(),
    "B" => Value::test_int(42),
    "C" => Value::test_nothing(),
    "D" => Value::test_int(42),
};
let mut cased_rec: DynCasedRecord<&mut Record> = rec.cased_mut(Casing::Insensitive);

The following will fail to compile:

let a = cased_rec.get_mut("a");
let b = cased_rec.get_mut("b");

This is due to the fact .get_mut() receives self¹ by value, which limits its use to just once, unless we construct a new DynCasedRecord.

We can create a new DynCasedRecord<&mut Record> from an existing one even though &mut T is not Copy. This is accomplished with reborrowing which happens implicitly with native references. Reborrowing also happens to be a tragically under documented feature of rust.

Though there isn’t a trait for it yet, it’s possible and simple to implement, it just has to be called explicitly:

let a = cased_rec.reborrow_mut().get_mut("a");
let b = cased_rec.reborrow_mut().get_mut("b");

---

1. Receiving &mut self works, but has an undesirable effect on the return value’s lifetime. With Self == &'wrapper mut DynCasedRecord<&'source mut Record>, return value’s lifetime will be 'wrapper rather than 'source. ↩

pub fn get_mut(self, col: impl AsRef<str>) -> Option<&'a mut Value>

pub fn remove(self, col: impl AsRef<str>) -> Option<Value>

pub fn insert<K>(self, col: K, val: Value) -> Option<Value>

where K: AsRef<str> + Into<String>,

Insert into the record, replacing preexisting value if found.

Returns Some(previous_value) if found. Else None

Trait Implementations

impl Clone for DynCasedRecord<&Record>

fn clone(&self) -> DynCasedRecord<&Record>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DynCasedRecord<&Record>