extendr_api/robj/debug.rs
1use crate::wrapper::*;
2// use crate::robj::GetSexp;
3use crate::robj::Attributes;
4use crate::robj::Rany;
5use crate::robj::Rinternals;
6use crate::robj::Robj;
7use crate::robj::Types;
8
9impl std::fmt::Debug for Symbol {
10 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11 if self.is_missing_arg() {
12 write!(f, "missing_arg()")
13 } else if self.is_unbound_value() {
14 write!(f, "unbound_value()")
15 } else {
16 write!(f, "sym!({})", self.as_symbol().unwrap().as_str())
17 }
18 }
19}
20
21/// Implement {:?} formatting.
22impl std::fmt::Debug for Robj {
23 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
24 match self.as_any() {
25 Rany::Null(_) => write!(f, "()"),
26 Rany::Symbol(value) => value.fmt(f),
27 Rany::Pairlist(value) => value.fmt(f),
28 Rany::Function(value) => value.fmt(f),
29 Rany::Environment(value) => value.fmt(f),
30 Rany::Promise(value) => value.fmt(f),
31 Rany::Language(value) => value.fmt(f),
32 Rany::Special(value) => value.fmt(f),
33 Rany::Builtin(value) => value.fmt(f),
34 Rany::Rstr(value) => value.fmt(f),
35 Rany::Logicals(value) => value.fmt(f),
36 Rany::Integers(value) => value.fmt(f),
37 Rany::Doubles(value) => value.fmt(f),
38 Rany::Complexes(value) => value.fmt(f),
39 Rany::Strings(value) => write!(f, "{:?}", value.as_slice()),
40 Rany::Dot(_dot) => write!(f, "Dot"),
41 Rany::Any(_any) => write!(f, "Any"),
42 Rany::List(value) => value.fmt(f),
43 Rany::Expressions(value) => value.fmt(f),
44 Rany::Bytecode(_bytecode) => write!(f, "Bytecode"),
45 Rany::ExternalPtr(_externalptr) => write!(f, "ExternalPtr"),
46 Rany::WeakRef(_weakref) => write!(f, "Weakref"),
47 Rany::Raw(value) => value.fmt(f),
48 Rany::S4(value) => value.fmt(f),
49 Rany::Unknown(_unknown) => write!(f, "Unknown"),
50 }?;
51 /*
52 match self.sexptype() {
53 NILSXP => write!(f, "r!(NULL)"),
54 SYMSXP => {
55 if self.is_missing_arg() {
56 write!(f, "missing_arg()")
57 } else if self.is_unbound_value() {
58 write!(f, "unbound_value()")
59 } else {
60 write!(f, "sym!({})", self.as_symbol().unwrap().as_str())
61 }
62 }
63 LISTSXP => {
64 let pairlist = self.as_pairlist().unwrap().iter();
65 write!(f, "r!({:?})", pairlist)
66 }
67 CLOSXP => {
68 let func = self.as_function().unwrap();
69 let formals = func.formals();
70 let body = func.body();
71 let environment = func.environment();
72 write!(
73 f,
74 "r!(Function::from_parts({:?}, {:?}, {:?}))",
75 formals, body, environment
76 )
77 }
78 ENVSXP => unsafe {
79 let sexp = self.get();
80 if sexp == R_GlobalEnv {
81 write!(f, "global_env()")
82 } else if sexp == R_BaseEnv {
83 write!(f, "base_env()")
84 } else if sexp == R_EmptyEnv {
85 write!(f, "empty_env()")
86 } else {
87 write!(f, "r!(Environment::from_pairs(...))")
88 }
89 },
90 PROMSXP => {
91 let p = self.as_promise().unwrap();
92 write!(
93 f,
94 "r!(Promise::from_parts({:?}, {:?}))",
95 p.code(),
96 p.environment()
97 )
98 }
99 LANGSXP => write!(
100 f,
101 "r!(Language::from_values({:?}))",
102 self.as_language().unwrap().values().collect::<Vec<_>>()
103 ),
104 SPECIALSXP => write!(f, "r!(Special())"),
105 BUILTINSXP => write!(f, "r!(Builtin())"),
106 CHARSXP => {
107 let c = Rstr::try_from(self.clone()).unwrap();
108 write!(f, "r!(Rstr::from_string({:?}))", c.as_str())
109 }
110 LGLSXP => {
111 let slice = self.as_logical_slice().unwrap();
112 if slice.len() == 1 {
113 write!(f, "r!({:?})", slice[0])
114 } else {
115 write!(f, "r!({:?})", slice)
116 }
117 }
118 INTSXP => {
119 let slice = self.as_integer_slice().unwrap();
120 if slice.len() == 1 {
121 write!(f, "r!({:?})", slice[0])
122 } else {
123 write!(f, "r!({:?})", self.as_integer_slice().unwrap())
124 }
125 }
126 REALSXP => {
127 let slice = self.as_real_slice().unwrap();
128 if slice.len() == 1 {
129 write!(f, "r!({:?})", slice[0])
130 } else {
131 write!(f, "r!({:?})", slice)
132 }
133 }
134 VECSXP => {
135 let list = self.as_list().unwrap();
136 if self.names().is_some() {
137 write!(f, "r!(List::from_pairs({:?}))", list.iter())
138 } else {
139 write!(f, "r!(List::from_values({:?}))", list.values())
140 }
141 }
142 EXPRSXP => write!(
143 f,
144 "r!(Expressions::from_values({:?}))",
145 self.as_expressions().unwrap().values()
146 ),
147 WEAKREFSXP => write!(f, "r!(Weakref())"),
148 // CPLXSXP => false,
149 STRSXP => {
150 write!(f, "r!([")?;
151 let mut sep = "";
152 for s in self.as_str_iter().unwrap() {
153 // if s.is_na() {
154 // write!(f, "{}na_str()", sep)?;
155 // } else {
156 write!(f, "{}{:?}", sep, s)?;
157 // }
158 sep = ", ";
159 }
160 write!(f, "])")
161 }
162 DOTSXP => write!(f, "r!(Dot())"),
163 ANYSXP => write!(f, "r!(Any())"),
164 BCODESXP => write!(f, "r!(Bcode())"),
165 EXTPTRSXP => {
166 write!(f, "r!(ExternalPtr())")
167 }
168 RAWSXP => {
169 write!(
170 f,
171 "r!(Raw::from_bytes({:?}))",
172 self.as_raw().unwrap().as_slice()
173 )
174 }
175 S4SXP => write!(f, "r!(S4())"),
176 NEWSXP => write!(f, "r!(New())"),
177 FREESXP => write!(f, "r!(Free())"),
178 _ => write!(f, "??"),
179 }?;
180 */
181 if let Some(c) = self.class() {
182 write!(f, ".set_class({:?}", c)?;
183 }
184 Ok(())
185 }
186}