1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
//! Dictionaries for Compute.
#![deprecated(since = "0.8.6", note = "renamed to `config_store`")]
#![allow(deprecated)]
pub(crate) mod handle;
use handle::DictionaryHandle;
pub use handle::{LookupError, OpenError};
/// Maximum Edge Dictionary value size.
///
/// This constant is determined by consulting Fastly's [Edge Dictionary documentation][1]:
///
/// > Dictionary containers, item keys, and their values have specific limits. Dictionary
/// > containers are limited to 1000 items. Dictionary item keys are limited to 256 characters and
/// > their values are limited to 8000 characters.
///
/// This constant is used as the default buffer size for dictionary values when using the
/// high-level dictionary API.
///
/// [1]: https://docs.fastly.com/en/guides/about-edge-dictionaries#limitations-and-considerations
const MAX_LEN: usize = 8000;
/// A Compute Dictionary.
#[deprecated(since = "0.8.6", note = "renamed to `ConfigStore`")]
pub struct Dictionary {
handle: DictionaryHandle,
}
impl Dictionary {
/// Open a dictionary, given its name.
///
/// # Examples
///
/// ```ignore
/// # use fastly::Dictionary;
/// let merriam = Dictionary::open("merriam webster");
/// let oed = Dictionary::open("oxford english dictionary");
/// ```
#[deprecated(since = "0.8.6", note = "use method on `ConfigStore` instead")]
pub fn open(name: &str) -> Self {
let handle = match DictionaryHandle::open(name) {
Ok(h) if h.is_valid() => h,
Ok(_) => panic!("could not open dictionary `{}`", name),
Err(e) => panic!("could not open dictionary `{}`: {}", name, e),
};
Self { handle }
}
/// Try to open a dictionary, given its name.
///
/// # Examples
///
/// ```ignore
/// # use fastly::dictionary::*;
/// let merriam = Dictionary::try_open("merriam webster").unwrap();
/// ```
#[deprecated(since = "0.8.6", note = "use method on `ConfigStore` instead")]
pub fn try_open(name: &str) -> Result<Self, OpenError> {
DictionaryHandle::open(name).map(|handle| Self { handle })
}
/// Lookup a value in this dictionary.
///
/// If successful, this function returns `Some(_)` if an entry was found, or `None` if no entry
/// with the given key was found.
///
/// # Examples
///
/// ```ignore
/// # use fastly::Dictionary;
/// # let dictionary = Dictionary::open("test dictionary");
/// #
/// assert_eq!(
/// dictionary.get("bread"),
/// Some(String::from("a usually baked and leavened food")),
/// );
/// assert_eq!(
/// dictionary.get("freedom"),
/// Some(String::from("the absence of necessity, coercion, or constraint")),
/// );
///
/// // Otherwise, `get` will return nothing.
/// assert!(dictionary.get("zzzzz").is_none());
/// ```
///
/// # Panics
///
/// This may panic for any of the reasons that [`Dictionary::try_get`] would return an error.
#[deprecated(since = "0.8.6", note = "use method on `ConfigStore` instead")]
pub fn get(&self, key: &str) -> Option<String> {
self.try_get(key)
.unwrap_or_else(|e| panic!("lookup for key `{}` failed: {}", key, e))
}
/// Try to lookup a value in this dictionary.
///
/// If successful, this function returns `Ok(Some(_))` if an entry was found, or `Ok(None)` if
/// no entry with the given key was found. This function returns `Err(_)` if the lookup failed.
///
/// # Examples
///
/// ```ignore
/// # use fastly::Dictionary;
/// # let dictionary = Dictionary::open("test dictionary");
/// #
/// assert_eq!(
/// dictionary.try_get("bread").unwrap(),
/// Some(String::from("a usually baked and leavened food")),
/// );
/// assert_eq!(
/// dictionary.try_get("freedom").unwrap(),
/// Some(String::from("the absence of necessity, coercion, or constraint")),
/// );
///
/// // Otherwise, `try_get` will return nothing.
/// assert!(dictionary.try_get("zzzzz").unwrap().is_none());
/// ```
#[deprecated(since = "0.8.6", note = "use method on `ConfigStore` instead")]
pub fn try_get(&self, key: &str) -> Result<Option<String>, LookupError> {
self.handle.get(key, MAX_LEN)
}
/// Return true if the dictionary contains an entry with the given key.
///
/// # Examples
///
/// ```ignore
/// # use fastly::Dictionary;
/// # let dictionary = Dictionary::open("test dictionary");
/// #
/// assert!(dictionary.contains("key"));
/// ```
///
/// # Panics
///
/// This may panic for any of the reasons that [`Dictionary::try_get`] would return an error.
#[deprecated(since = "0.8.6", note = "use method on `ConfigStore` instead")]
pub fn contains(&self, key: &str) -> bool {
self.handle
.contains(key)
.unwrap_or_else(|e| panic!("lookup for key `{}` failed: {}", key, e))
}
}