Unable to parse JSON tree generated with custom cursor

[rychale]

Hi,

I'm trying to implement custom cursor reading Elixir terms. The problem I unable to solve is that when I'm calling decoder.get_result().template as<T>();

I get following error:
Attempting to access or modify 'timestamp' on a value that is not an object

The events the cursor pushed to decoder are:
begin_object key int64_value end_object

I had to write template specialisation for decor_traits:

 14 struct decode_traits<T, erl_term_cursor<S>, void>                                                                                                                                                      
 13 {                                                                                                                                                                                                      
 12         template <class Json,class TempAllocator>                                                                                                                                                      
 11         static T decode(erl_term_cursor<S>& cursor,                                                                                                                                                    
 10                         json_decoder<Json,TempAllocator>& decoder,                                                                                                                                     
  9                         std::error_code& ec)                                                                                                                                                           
  8         {                                                                                                                                                                                              
  7                 decoder.reset();                                                                                                                                                                       
  6                 cursor.read_to(decoder, ec);                                                                                                                                                           
  5                                                                                                                                                                                                        
  4                 std::string s;                                                                                                                                                                         
  3                 jsoncons::encode_json_pretty(decoder.get_result(), s);                                                                                                                                 
  2                 std::cout << s << std::endl;
  1                                                                                                                                                                                                        
  0                 return decoder.get_result().template as<T>();

As you can see on the line 2 I print JSON generated, so here it is:

{
    "timestamp": 1600254272
}

The line 0 actually throws the exception.

The cursor implemented parses complete tree of the terms and generates vector of jsoncons::basic_staj_event in constructor.

 38         bool done() const                                                                                               
 37         {                                                                                                               
 36                 return v_.end() == iterator_;                                                                           
 35         }                                                                                                               
 34                                                                                                                         
 33         const jsoncons::basic_staj_event<CharT>& current() const                                                        
 32         {                                                                                                               
 31                 return *iterator_;                                                                                      
 30         }                                                                                                               
 29                                                                                                                         
 28         void next()                                                                                                     
 27         {                                                                                                               
 26                 iterator_ = std::next(iterator_);                                                                       
 25         }                                                                                                               
 19                                                                                                                         
 18         void read_to(jsoncons::basic_json_visitor<CharT>& visitor, std::error_code& ec)                                 
 17         {                                                                                                               
 16                 while(!done())                                                                                          
 15                 {                                                                                                       
 14                         std::cout << current().event_type() << std::endl;                                               
 13                         staj_to_saj_event(current(), visitor, context_, ec);                                            
 12                         next();                                                                                         
 11                 }                                                                                                       
 10         }

I'll be very appreciated for your help.

Thanks

[danielaparker]

decoder.get_result() is only intended to be called once, it moves the result value into the destination (probably it should be changed to throw if called twice.)

Try

 4                 std::string s;      
                    auto j =  decoder.get_result();          
  3                 jsoncons::encode_json_pretty(j, s); 
  2                 std::cout << s << std::endl;
  1                 
  0                 return j.template as<T>();

Is there a reason why you need to parameterize on erl_term_cursor<S>? Assuming erl_term_cursor<S> implements basic_staj_cursor<char>, a specialization of decode_traits should only require a basic_staj_cursor<char>. Each specialization is intended to support all kinds of cursors including json_cursor, cbor_cursor, etc.

[rychale]

Hi,

First of all, thank you, it works!

As for specialisation, I've removed that special decode_traits code. The only one I had to implement is decode_json:

 template <class T>                                                                                                                                                                                     
 T decode_json(const nifpp::erl_term_wrapper& s)                                                                                                                                                        
 {                                                                                                                                                                                                      
         using char_type = char;                                                                                                                                                                        
                                                                                                                                                                                                        
         nifpp::erl_term_cursor<char_type, nifpp::erl_term_wrapper> cursor(s);                                                                                                                          
         jsoncons::json_decoder<basic_json<char_type>>              decoder;                                                                                                                            
         std::error_code                                            ec;                                                                                                                                 
                                                                                                                                                                                                        
         T val = decode_traits<T, char_type>::decode(cursor, decoder, ec);                                                                                                                              
                                                                                                                                                                                                        
         if(ec)                                                                                                                                                                                         
         {                                                                                                                                                                                              
                 JSONCONS_THROW(ser_error(ec, cursor.context().line(), cursor.context().column()));                                                                                                     
         }                                                                                                                                                                                              
                                                                                                                                                                                                        
         return val;                                                                                                                                                                                    
 }

since

std::enable_if<!is_basic_json<T>::value &&
                            jsoncons::detail::is_char_sequence<Source>::value,T>::type

is False in case of erl_term_wrapper.