hornvale/scripting_language/instance/
mod.rs

1use std::any::Any;
2use std::fmt::{Formatter, Result as FmtResult};
3use std::mem::size_of;
4
5use crate::scripting_language::class::Class;
6use crate::scripting_language::garbage_collection::collector::Collector as GarbageCollector;
7use crate::scripting_language::garbage_collection::reference::Reference;
8use crate::scripting_language::garbage_collection::trace::Trace;
9use crate::scripting_language::table::Table;
10use crate::scripting_language::value::Value;
11
12/// The `Instance` type.
13#[derive(Debug)]
14pub struct Instance {
15  /// The class of which this is an instance.
16  pub class: Reference<Class>,
17  /// A table of fields and their values.
18  pub fields: Table,
19}
20
21impl Instance {
22  /// Constructor.
23  #[named]
24  pub fn new(class: Reference<Class>) -> Self {
25    trace_enter!();
26    trace_var!(class);
27    let fields = Table::new();
28    trace_var!(fields);
29    let result = Instance { class, fields };
30    trace_var!(result);
31    trace_exit!();
32    result
33  }
34}
35
36impl Trace for Instance {
37  #[named]
38  fn format(&self, f: &mut Formatter, garbage_collector: &GarbageCollector) -> FmtResult {
39    trace_enter!();
40    trace_var!(garbage_collector);
41    let class = garbage_collector.deref(self.class);
42    trace_var!(class);
43    let name = garbage_collector.deref(class.name);
44    trace_var!(name);
45    let result = write!(f, "{} instance", name);
46    trace_var!(result);
47    trace_exit!();
48    result
49  }
50  #[named]
51  fn get_size(&self) -> usize {
52    trace_enter!();
53    let result = size_of::<Instance>() + self.fields.capacity() * (size_of::<Reference<String>>() + size_of::<Value>());
54    trace_var!(result);
55    trace_exit!();
56    result
57  }
58  #[named]
59  fn trace(&self, garbage_collector: &mut GarbageCollector) {
60    trace_enter!();
61    garbage_collector.mark_object(self.class);
62    garbage_collector.mark_table(&self.fields);
63    trace_exit!();
64  }
65  #[named]
66  fn as_any(&self) -> &dyn Any {
67    trace_enter!();
68    let result = self;
69    trace_var!(result);
70    trace_exit!();
71    result
72  }
73  #[named]
74  fn as_any_mut(&mut self) -> &mut dyn Any {
75    trace_enter!();
76    let result = self;
77    trace_var!(result);
78    trace_exit!();
79    result
80  }
81}