use alloc::collections::BTreeMap;
use alloc::rc::Rc;
use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;
use core::cell::RefCell;
use crate::classes::enumerator;
use crate::runtime::{Object, Runtime, RuntimeError, RuntimeFailure, Value, put};
const STATE: &str = "map state";
const STATE_CLASS: &str = "map-state";
const PROPERTIES: [&str; 4] = ["count", "capacity", "casesense", "__item"];
const METHODS: [&str; 17] = [
"set",
"get",
"has",
"delete",
"clear",
"clone",
"__new",
"__enum",
"ownprops",
"hasownprop",
"defineprop",
"deleteprop",
"getownpropdesc",
"hasprop",
"hasmethod",
"getmethod",
"hasbase",
];
pub(crate) fn names() -> Vec<&'static str> {
PROPERTIES.iter().chain(METHODS.iter()).copied().collect()
}
#[derive(Clone, Copy)]
enum CaseSense {
On,
Off,
Locale,
}
pub(crate) fn construct(
arguments: &[Value],
_rt: &mut Runtime,
line: u32,
) -> Result<Value, RuntimeFailure> {
if arguments.len() % 2 != 0 {
return Err(RuntimeFailure::Error(RuntimeError {
message: "Invalid number of parameters.".into(),
line,
}));
}
let map = crate::classes::object_with(
"map",
vec![(STATE, new_state(Vec::new(), CaseSense::On, 0))],
);
for pair in arguments.chunks(2) {
set_pair(&map, &pair[0], pair[1].clone());
}
Ok(map)
}
pub(crate) fn call(
method: &str,
this: &Value,
arguments: &[Value],
rt: &mut Runtime,
line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
let method = method.to_lowercase();
let failure = |message: &str| {
Some(Err(RuntimeFailure::Error(RuntimeError {
message: message.to_string(),
line,
})))
};
let failure_with = |message: &str, extra: &str| {
Some(Err(crate::classes::the_failure_with(message, extra, line)))
};
if rt.dialect().carries_the_member_of_the_extension("map", &method) {
if method == "tostring" {
return Some(the_extension_tostring(this, rt, line));
}
return None;
}
match method.as_str() {
"set" | "__new" => {
if arguments.len() % 2 != 0 {
return failure("Invalid number of parameters.");
}
for pair in arguments.chunks(2) {
set_pair(this, &pair[0], pair[1].clone());
}
Some(Ok(this.clone()))
}
"get" => {
let Some(key) = arguments.first() else {
return failure("Too few parameters passed to function.");
};
match find(this, key) {
Some(value) => Some(Ok(value)),
None => match arguments.get(1) {
Some(default) => Some(Ok(default.clone())),
None => match default_property(this) {
Some(default) => Some(Ok(default)),
None => failure_with("Item has no value.", &key.to_text()),
},
},
}
}
"has" => {
let Some(key) = arguments.first() else {
return failure("Too few parameters passed to function.");
};
Some(Ok(Value::Int(find(this, key).is_some() as i64)))
}
"delete" => {
let Some(key) = arguments.first() else {
return failure("Too few parameters passed to function.");
};
let Some(state) = state(this) else {
return failure("Item has no value.");
};
let mut state = state.borrow_mut();
let sense = case_sense(&state);
let mut pairs = entries(&state);
let Some(index) = pairs
.iter()
.position(|(existing, _)| same_key(existing, key, sense))
else {
return failure_with("Item has no value.", &key.to_text());
};
let (_, value) = pairs.remove(index);
set_entries(&mut state, pairs);
Some(Ok(value))
}
"clear" => {
if let Some(state) = state(this) {
let mut state = state.borrow_mut();
set_entries(&mut state, Vec::new());
}
Some(Ok(Value::Text(String::new())))
}
"clone" => Some(Ok(clone(this))),
"__enum" => {
let Some(state) = state(this) else {
return Some(Ok(enumerator::make(Vec::new(), enumerator::Alone::TheKey)));
};
let state = state.borrow();
Some(Ok(enumerator::make(
entries(&state),
enumerator::Alone::TheKey,
)))
}
_ => base_method(&method, this, arguments, rt, line),
}
}
pub(crate) fn set_item(
key: &Value,
this: &Value,
value: Value,
_rt: &mut Runtime,
_line: u32,
) -> Option<Result<(), RuntimeFailure>> {
set_pair(this, key, value);
Some(Ok(()))
}
pub(crate) fn property(
name: &str,
this: &Value,
_rt: &mut Runtime,
_line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
let state = state(this)?;
let state = state.borrow();
match name {
"count" => Some(Ok(Value::Int(entries(&state).len() as i64))),
"capacity" => Some(Ok(Value::Int(capacity(&state)))),
"casesense" => Some(Ok(Value::Text(
case_sense_text(case_sense(&state)).to_string(),
))),
_ => None,
}
}
pub(crate) fn set_property(
name: &str,
this: &Value,
value: Value,
rt: &mut Runtime,
line: u32,
) -> Option<Result<(), RuntimeFailure>> {
let failure = |message: &str| {
Some(Err(RuntimeFailure::Error(RuntimeError {
message: message.to_string(),
line,
})))
};
let failure_with = |message: &str, extra: &str| {
Some(Err(crate::classes::the_failure_with(message, extra, line)))
};
match name {
"capacity" => {
let wanted = match rt.integer(&value, line) {
Ok(number) => number,
Err(failure) => return Some(Err(failure)),
};
let wanted = wanted as u32 as i64;
let state = state(this)?;
let mut state = state.borrow_mut();
let count = entries(&state).len() as i64;
set_capacity(&mut state, wanted.max(count));
Some(Ok(()))
}
"casesense" => {
let Some(sense) = case_sense_of(&value) else {
return failure_with("Invalid value.", &value.to_text());
};
let state = state(this)?;
let mut state = state.borrow_mut();
if !entries(&state).is_empty() {
return failure("Map must be empty");
}
set_case_sense(&mut state, sense);
Some(Ok(()))
}
_ => None,
}
}
pub(crate) fn item(
key: &Value,
this: &Value,
_rt: &mut Runtime,
line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
match find(this, key) {
Some(value) => Some(Ok(value)),
None => match default_property(this) {
Some(default) => Some(Ok(default)),
None => Some(Err(crate::classes::the_failure_with(
"Item has no value.",
&key.to_text(),
line,
))),
},
}
}
fn state(map: &Value) -> Option<Rc<RefCell<Object>>> {
let Value::Object(object) = map else {
return None;
};
let state = object.borrow().value_of(STATE)?;
match state {
Value::Object(state) => Some(state),
_ => None,
}
}
fn new_state(pairs: Vec<(Value, Value)>, sense: CaseSense, capacity: i64) -> Value {
let mut state = Object {
class: STATE_CLASS.to_string(),
properties: BTreeMap::new(),
};
set_entries(&mut state, pairs);
set_case_sense(&mut state, sense);
set_capacity(&mut state, capacity);
Value::Object(Rc::new(RefCell::new(state)))
}
fn entries(state: &Object) -> Vec<(Value, Value)> {
let Some(Value::List(items)) = state.value_of("entries") else {
return Vec::new();
};
items
.iter()
.map(|entry| match entry {
Value::List(pair) if pair.len() == 2 => (pair[0].clone(), pair[1].clone()),
_ => (Value::Text(String::new()), Value::Text(String::new())),
})
.collect()
}
pub(crate) fn the_pairs(this: &Value) -> Option<Vec<(Value, Value)>> {
let state = state(this)?;
Some(entries(&state.borrow()))
}
fn set_entries(state: &mut Object, pairs: Vec<(Value, Value)>) {
let items: Vec<Value> = pairs
.into_iter()
.map(|(key, value)| Value::List(vec![key, value]))
.collect();
put(&mut state.properties, "entries", Value::List(items));
}
fn case_sense(state: &Object) -> CaseSense {
let setting = state
.value_of("casesense")
.map(|value| value.to_text())
.unwrap_or_default();
match setting.to_lowercase().as_str() {
"off" => CaseSense::Off,
"locale" => CaseSense::Locale,
_ => CaseSense::On,
}
}
fn set_case_sense(state: &mut Object, sense: CaseSense) {
put(
&mut state.properties,
"casesense",
Value::Text(case_sense_text(sense).to_string()),
);
}
fn capacity(state: &Object) -> i64 {
state
.value_of("capacity")
.and_then(|value| value.to_number())
.map(|number| number as i64)
.unwrap_or(0)
}
fn set_capacity(state: &mut Object, capacity: i64) {
put(&mut state.properties, "capacity", Value::Int(capacity));
}
fn case_sense_text(sense: CaseSense) -> &'static str {
match sense {
CaseSense::On => "On",
CaseSense::Off => "Off",
CaseSense::Locale => "Locale",
}
}
fn case_sense_of(value: &Value) -> Option<CaseSense> {
match value {
Value::Int(1) => Some(CaseSense::On),
Value::Int(0) => Some(CaseSense::Off),
other => {
let setting = other.to_text().to_lowercase();
match setting.as_str() {
"on" => Some(CaseSense::On),
"off" => Some(CaseSense::Off),
"locale" => Some(CaseSense::Locale),
_ => None,
}
}
}
}
fn find(map: &Value, key: &Value) -> Option<Value> {
let state = state(map)?;
let state = state.borrow();
let sense = case_sense(&state);
entries(&state)
.into_iter()
.find(|(existing, _)| same_key(existing, key, sense))
.map(|(_, value)| value)
}
fn default_property(map: &Value) -> Option<Value> {
let Value::Object(object) = map else {
return None;
};
object.borrow().value_of("default")
}
fn set_pair(map: &Value, key: &Value, value: Value) {
let Some(state) = state(map) else { return };
let mut state = state.borrow_mut();
let sense = case_sense(&state);
let mut pairs = entries(&state);
match pairs
.iter()
.position(|(existing, _)| same_key(existing, key, sense))
{
Some(index) => pairs[index].1 = value,
None => pairs.push((key.clone(), value)),
}
let count = pairs.len() as i64;
set_entries(&mut state, pairs);
if count > capacity(&state) {
set_capacity(&mut state, count);
}
}
fn clone(map: &Value) -> Value {
let (pairs, sense, capacity) = match state(map) {
Some(state) => {
let state = state.borrow();
(entries(&state), case_sense(&state), capacity(&state))
}
None => (Vec::new(), CaseSense::On, 0),
};
let mut properties = BTreeMap::new();
put(&mut properties, STATE, new_state(pairs, sense, capacity));
if let Value::Object(object) = map {
for (name, property) in object.borrow().properties.iter() {
if name != STATE {
properties.insert(name.clone(), property.clone());
}
}
}
Value::Object(Rc::new(RefCell::new(Object {
class: "map".to_string(),
properties,
})))
}
fn same_key(left: &Value, right: &Value, sense: CaseSense) -> bool {
match (left, right) {
(Value::Object(left), Value::Object(right)) => Rc::ptr_eq(left, right),
(Value::Object(_), _) | (_, Value::Object(_)) => false,
(Value::Float(_), _) | (_, Value::Float(_)) => {
same_text(&left.to_text(), &right.to_text(), sense)
}
(Value::Int(left), Value::Int(right)) => left == right,
(Value::Text(left), Value::Text(right)) => same_text(left, right, sense),
_ => false,
}
}
fn same_text(left: &str, right: &str, sense: CaseSense) -> bool {
match sense {
CaseSense::On => left == right,
CaseSense::Off => left.eq_ignore_ascii_case(right),
CaseSense::Locale => left.to_lowercase() == right.to_lowercase(),
}
}
fn base_method(
method: &str,
this: &Value,
arguments: &[Value],
rt: &mut Runtime,
line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
let Value::Object(object) = this else {
return None;
};
let failure = |message: &str| {
Some(Err(RuntimeFailure::Error(RuntimeError {
message: message.to_string(),
line,
})))
};
let name = arguments
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let key = name.to_lowercase();
match method {
"ownprops" => {
let pairs: Vec<(Value, Value)> = object
.borrow()
.properties
.iter()
.filter(|(name, _)| name.as_str() != STATE)
.map(|(_, property)| (Value::Text(property.name.clone()), property.value.clone()))
.collect();
Some(Ok(enumerator::make(pairs, enumerator::Alone::TheKey)))
}
"hasownprop" => Some(Ok(Value::Int(own_property(object, &key) as i64))),
"hasprop" => Some(Ok(Value::Int(
(PROPERTIES.contains(&key.as_str())
|| METHODS.contains(&key.as_str())
|| own_property(object, &key)
|| key == "__class"
|| key == "__init"
|| key == "base") as i64,
))),
"hasmethod" => Some(Ok(Value::Int(
(METHODS.contains(&key.as_str())
|| key == "__init") as i64,
))),
"getownpropdesc" => {
let name = arguments
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let value = object.borrow().value_of(&key);
match value {
Some(value) => {
let table = match rt.the_members_of_a_descriptor(&value) {
Some(members) => members,
None => {
let mut table = BTreeMap::new();
put(&mut table, "value", value);
table
}
};
Some(Ok(Value::Object(Rc::new(RefCell::new(Object {
class: "object".to_string(),
properties: table,
})))))
}
None => Some(Err(rt.no_property(this, &name, line))),
}
}
"defineprop" => {
if key == STATE {
return failure("the state of a map is not a property of it.");
}
let descriptor = match rt.the_descriptor(arguments.get(1), line) {
Ok(descriptor) => descriptor,
Err(failure) => return Some(Err(failure)),
};
put(&mut object.borrow_mut().properties, &name, descriptor);
Some(Ok(this.clone()))
}
"deleteprop" => {
if key == STATE {
return Some(Ok(Value::Text(String::new())));
}
let gone = object
.borrow_mut()
.properties
.remove(&key)
.map(|property| property.value);
Some(Ok(match gone {
None => Value::Text(String::new()),
Some(value) => match rt.the_value_of_the_descriptor(&value, this, &name, line) {
Ok(Some(value)) => value,
_ => value,
},
}))
}
_ => None,
}
}
fn own_property(object: &Rc<RefCell<Object>>, key: &str) -> bool {
key != STATE && object.borrow().properties.contains_key(key)
}
fn the_extension_tostring(this: &Value, rt: &mut Runtime, line: u32) -> Result<Value, RuntimeFailure> {
let Some(state) = state(this) else {
return Ok(Value::Text("[]".to_string()));
};
let entries = entries(&state.borrow());
let mut out = String::new();
out.push('[');
for (index, (key, value)) in entries.iter().enumerate() {
if index > 0 {
out.push_str(", ");
}
out.push_str(&super::array::the_text_of_a_value(key, rt, line));
out.push_str(": ");
out.push_str(&super::array::the_text_of_a_value(value, rt, line));
}
out.push(']');
Ok(Value::Text(out))
}