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}