use std::{cell::RefCell, iter::FromIterator, ops::{DerefMut, Deref}, rc::Rc};
use crate::{InternalString, RantValue};
use fnv::FnvHashMap;
const LIST_INLINE_SIZE: usize = 2;
pub type RantMapRef = Rc<RefCell<RantMap>>;
pub type RantListRef = Rc<RefCell<RantList>>;
#[derive(Debug, Clone, PartialEq)]
pub struct RantList(Vec<RantValue>);
impl RantList {
pub fn new() -> Self {
Self(vec![])
}
pub fn with_capacity(capacity: usize) -> Self {
Self(Vec::with_capacity(capacity))
}
#[inline(always)]
pub fn len(&self) -> usize {
self.0.len()
}
#[inline(always)]
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
}
impl From<Vec<RantValue>> for RantList {
fn from(list: Vec<RantValue>) -> Self {
Self(list)
}
}
impl Default for RantList {
fn default() -> Self {
Self::new()
}
}
impl Deref for RantList {
type Target = Vec<RantValue>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for RantList {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl FromIterator<RantValue> for RantList {
fn from_iter<T: IntoIterator<Item = RantValue>>(iter: T) -> Self {
let mut list = Self::new();
for item in iter {
list.push(item);
}
list
}
}
impl IntoIterator for RantList {
type Item = RantValue;
type IntoIter = std::vec::IntoIter<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()
}
}
#[derive(Debug, Clone)]
pub struct RantMap {
map: FnvHashMap<InternalString, RantValue>,
proto: Option<RantMapRef>
}
impl RantMap {
pub fn new() -> Self {
Self {
map: Default::default(),
proto: None
}
}
#[inline]
pub fn clear(&mut self) {
self.map.clear();
}
#[inline]
pub fn raw_len(&self) -> usize {
self.map.len()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.map.is_empty()
}
#[inline]
pub fn proto(&self) -> Option<RantMapRef> {
self.proto.clone()
}
#[inline]
pub fn extend<M: Deref<Target = RantMap>>(&mut self, other: M)
{
for (k, v) in other.map.iter() {
self.map.insert(k.clone(), v.clone());
}
}
#[inline]
pub fn set_proto(&mut self, proto: Option<RantMapRef>) {
self.proto = proto;
}
#[inline]
pub fn raw_set(&mut self, key: &str, val: RantValue) {
self.map.insert(InternalString::from(key), val);
}
#[inline]
pub fn raw_remove(&mut self, key: &str) {
self.map.remove(key);
}
#[inline]
pub fn raw_take(&mut self, key: &str) -> Option<RantValue> {
self.map.remove(key)
}
#[inline]
pub fn raw_get<'a>(&'a self, key: &str) -> Option<&'a RantValue> {
self.map.get(key)
}
#[inline]
pub fn raw_has_key(&self, key: &str) -> bool {
self.map.contains_key(key)
}
#[inline]
pub fn raw_keys(&self) -> RantList {
self.map.keys().map(|k| RantValue::String(k.as_str().into())).collect()
}
}
impl Default for RantMap {
fn default() -> Self {
RantMap::new()
}
}