Enum CapeStringHashKey

pub enum CapeStringHashKey<'a> {
    Owned(CapeStringConstNoCase),
    Borrowed(*const CapeCharacter, CapeSize, PhantomData<&'a ()>),
}

Class to store a platform dependent string encoding for use in case insensitive hash maps or for use of case insensitive comparisons.

For COBIA, strings go over the pipeline as null terminated. For Windows, COBIA requires UTF-16 encoding.

The CapeStringHashKey implementation uses a CapeStringConstNoCase to store, owned string data, or allows reference to data provided by any class that implements CapeStringConstProvider, so that a copy of the data is not needed for hash lookups.

A convenience class CapeOpenMap is defined, that uses the more performant hasher in the FxHasmap class and wraps members in accordance with the above requirements.

Note that this type cannot serve as a cape string provider, as this would require a mutable interface pointer.

Variants

Owned(CapeStringConstNoCase)

Borrowed(*const CapeCharacter, CapeSize, PhantomData<&'a ()>)

Implementations

impl<'a> CapeStringHashKey<'a>

pub fn from_string<T: AsRef<str>>(s: T) -> Self

Construct from string that owns the data

Arguments

• s - A string slice to be converted to a CapeStringHashKey

pub fn from_cape_char_const(ptr: *const CapeCharacter, size: CapeSize) -> Self

Construct from string that owns the data

Arguments

• ptr - A const CapeCharacter pointer
• size - Length of the string pointed to

pub fn from_string_constant<'b, T: CapeStringConstProvider>( c: &'b T, ) -> CapeStringHashKey<'b>

Construct from string constant provider reference that does not own the data

Arguments

• c - A string constant reference

pub fn as_string(&self) -> String

Return as string

Examples

use cobia;
let s=cobia::CapeStringHashKey::from_string("idealGasEnthalpy");
assert_eq!(s.as_string(),"idealgasenthalpy"); //note that CapeStringConstNoCase stores strings in lower case

Trait Implementations

impl<'a> Clone for CapeStringHashKey<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CapeStringHashKey<'a>

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

Formats the value using the given formatter.

impl<'a> Display for CapeStringHashKey<'a>

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

Formats the CapeStringConstNoCase error using the given formatter.

Examples

use cobia;
let s=cobia::CapeStringConstNoCase::from_string("idealGasEnthalpy");
assert_eq!(format!("{}",s),"idealgasenthalpy"); //note that CapeStringConstNoCase stores strings in lower case

impl<'a, T: AsRef<str>> From<T> for CapeStringHashKey<'a>

fn from(s: T) -> Self

Converts to this type from the input type.

impl<'a> Hash for CapeStringHashKey<'a>

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<'a> PartialEq for CapeStringHashKey<'a>

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<'a> Eq for CapeStringHashKey<'a>

impl<'a> Send for CapeStringHashKey<'a>

impl<'a> Sync for CapeStringHashKey<'a>