use std::cell::RefCell;
use std::rc::Rc;
use crate::vm::object::{JSObject, NativeFunctionObject};
use crate::vm::property::{ObjectKind, PropertyDescriptor, PropertyKey};
use crate::vm::value::{SymbolData, Value};
pub const ITERATOR_SYMBOL_ID: u64 = 0xFFFF_FFFF_FFFF_0000;
pub const ITERATOR_NATIVE_NAME: &str = "__iterator_factory__";
pub const ITERATOR_NEXT_PREFIX: &str = "__iter_next__";
pub const ITERATOR_RETURN_PREFIX: &str = "__iter_return__";
pub const GENERATOR_NEXT_PREFIX: &str = "__gen_next__";
pub const GENERATOR_ITERATOR_PREFIX: &str = "__gen_iterator__";
pub fn iterator_symbol_key() -> PropertyKey {
PropertyKey::Symbol(ITERATOR_SYMBOL_ID)
}
pub fn iterator_symbol_value() -> Value {
Value::Symbol(Rc::new(SymbolData::new(
Some("Symbol.iterator".to_string()),
ITERATOR_SYMBOL_ID,
)))
}
#[derive(Debug)]
pub enum NativeIteratorState {
Array { items: Vec<Value>, idx: usize },
String { chars: Vec<Value>, idx: usize },
Js { iterator: Value },
}
#[derive(Debug)]
pub struct NativeIteratorObject {
pub id: u64,
state: RefCell<NativeIteratorState>,
prototype: Option<Rc<RefCell<dyn JSObject>>>,
}
impl NativeIteratorObject {
pub fn new(id: u64, state: NativeIteratorState) -> Self {
Self {
id,
state: RefCell::new(state),
prototype: None,
}
}
pub fn state(&self) -> &RefCell<NativeIteratorState> {
&self.state
}
}
impl JSObject for NativeIteratorObject {
fn kind(&self) -> ObjectKind {
ObjectKind::Ordinary
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
self
}
fn property_get(&self, key: &PropertyKey) -> Option<PropertyDescriptor> {
if *key == crate::vm::iterator::iterator_symbol_key() {
return Some(PropertyDescriptor::data_descriptor(Value::Object(
Rc::new(RefCell::new(NativeFunctionObject::new(ITERATOR_NATIVE_NAME))),
)));
}
let native_name = match key.as_str() {
Some("next") => format!("{ITERATOR_NEXT_PREFIX}{}", self.id),
Some("return") => format!("{ITERATOR_RETURN_PREFIX}{}", self.id),
_ => return None,
};
Some(PropertyDescriptor::data_descriptor(Value::Object(
Rc::new(RefCell::new(NativeFunctionObject::new(&native_name))),
)))
}
fn property_set(&mut self, _key: PropertyKey, _value: Value) -> Result<bool, String> {
Err("Cannot add properties to an iterator".to_string())
}
fn define_property(
&mut self,
_key: PropertyKey,
_desc: PropertyDescriptor,
) -> Result<bool, String> {
Err("Cannot add properties to an iterator".to_string())
}
fn property_delete(&mut self, _key: &PropertyKey) -> bool {
false
}
fn has_property(&self, key: &PropertyKey) -> bool {
*key == crate::vm::iterator::iterator_symbol_key()
|| matches!(key.as_str(), Some("next") | Some("return"))
}
fn own_keys(&self) -> Vec<PropertyKey> {
vec![
PropertyKey::from_str("next"),
PropertyKey::from_str("return"),
]
}
fn get_prototype(&self) -> Option<Rc<RefCell<dyn JSObject>>> {
self.prototype.clone()
}
fn set_prototype(&mut self, proto: Option<Rc<RefCell<dyn JSObject>>>) {
self.prototype = proto;
}
fn is_extensible(&self) -> bool {
false
}
fn prevent_extensions(&mut self) {}
fn is_frozen(&self) -> bool {
true
}
fn freeze(&mut self) {}
fn is_sealed(&self) -> bool {
true
}
fn seal(&mut self) {}
fn type_of(&self) -> &'static str {
"object"
}
fn class_name(&self) -> &'static str {
"Iterator"
}
}
pub fn native_next(state: &mut NativeIteratorState) -> Option<Value> {
match state {
NativeIteratorState::Array { items, idx } | NativeIteratorState::String { chars: items, idx } => {
if *idx < items.len() {
let item = items[*idx].clone();
*idx += 1;
Some(item)
} else {
None
}
}
NativeIteratorState::Js { .. } => None,
}
}