1 #ifndef ZSERIO_JSON_PARSER_H_INC 
    2 #define ZSERIO_JSON_PARSER_H_INC 
   18 template <
typename ALLOC = std::allocator<u
int8_t>>
 
  111             m_tokenizer(in, allocator),
 
  145         return m_tokenizer.getLine();
 
  155         return m_tokenizer.getColumn();
 
  164     void parseElements();
 
  167     void visitValue() 
const;
 
  173     static const std::array<JsonToken, 3> ELEMENT_TOKENS;
 
  176     IObserver& m_observer;
 
  179 template <
typename ALLOC>
 
  180 const std::array<JsonToken, 3> BasicJsonParser<ALLOC>::ELEMENT_TOKENS = {
 
  183 template <
typename ALLOC>
 
  184 void BasicJsonParser<ALLOC>::parseElement()
 
  186     JsonToken token = m_tokenizer.getToken();
 
  202         throw createUnexpectedTokenException(ELEMENT_TOKENS);
 
  206 template <
typename ALLOC>
 
  207 void BasicJsonParser<ALLOC>::parseObject()
 
  210     m_observer.beginObject();
 
  218     m_observer.endObject();
 
  221 template <
typename ALLOC>
 
  222 void BasicJsonParser<ALLOC>::parseMembers()
 
  232 template <
typename ALLOC>
 
  233 void BasicJsonParser<ALLOC>::parseMember()
 
  236     const AnyHolder<ALLOC>& key = m_tokenizer.getValue();
 
  237     if (!key.template isType<string<ALLOC>>())
 
  239         throw JsonParserException(
"JsonParser:")
 
  240                 << getLine() << 
":" << getColumn() << 
": Key must be a string value!";
 
  242     m_observer.visitKey(key.template get<string<ALLOC>>());
 
  250 template <
typename ALLOC>
 
  251 void BasicJsonParser<ALLOC>::parseArray()
 
  254     m_observer.beginArray();
 
  256     if (std::find(ELEMENT_TOKENS.begin(), ELEMENT_TOKENS.end(), m_tokenizer.getToken()) != ELEMENT_TOKENS.end())
 
  262     m_observer.endArray();
 
  265 template <
typename ALLOC>
 
  266 void BasicJsonParser<ALLOC>::parseElements()
 
  276 template <
typename ALLOC>
 
  277 void BasicJsonParser<ALLOC>::parseValue()
 
  283 template <
typename ALLOC>
 
  284 void BasicJsonParser<ALLOC>::visitValue()
 const 
  286     const AnyHolder<ALLOC>& value = m_tokenizer.getValue();
 
  288     if (value.template isType<std::nullptr_t>())
 
  290         m_observer.visitValue(
nullptr);
 
  292     else if (value.template isType<bool>())
 
  294         m_observer.visitValue(value.template get<bool>());
 
  296     else if (value.template isType<int64_t>())
 
  298         m_observer.visitValue(value.template get<int64_t>());
 
  300     else if (value.template isType<uint64_t>())
 
  302         m_observer.visitValue(value.template get<uint64_t>());
 
  304     else if (value.template isType<double>())
 
  306         m_observer.visitValue(value.template get<double>());
 
  310         m_observer.visitValue(value.template get<string<ALLOC>>());
 
  314 template <
typename ALLOC>
 
  315 void BasicJsonParser<ALLOC>::checkToken(
JsonToken token)
 
  317     if (m_tokenizer.getToken() != token)
 
  319         throw createUnexpectedTokenException({{token}});
 
  323 template <
typename ALLOC>
 
  324 void BasicJsonParser<ALLOC>::consumeToken(
JsonToken token)
 
  330 template <
typename ALLOC>
 
  331 JsonParserException BasicJsonParser<ALLOC>::createUnexpectedTokenException(
 
  332         Span<const JsonToken> expecting)
 const 
  334     JsonParserException error(
"JsonParser:");
 
  335     error << getLine() << 
":" << getColumn() << 
": unexpected token: " << m_tokenizer.getToken();
 
  336     if (expecting.size() == 1)
 
  338         error << 
", expecting " << expecting[0] << 
"!";
 
  342         error << 
", expecting one of [";
 
  343         for (
size_t i = 0; i < expecting.size(); ++i)
 
  349             error << expecting[i];
 
virtual void endArray()=0
virtual void visitValue(uint64_t uintValue)=0
virtual void visitValue(int64_t intValue)=0
virtual void beginArray()=0
virtual void visitKey(StringView key)=0
virtual void beginObject()=0
virtual ~IObserver()=default
virtual void visitValue(std::nullptr_t nullValue)=0
virtual void visitValue(double doubleValue)=0
virtual void visitValue(StringView stringValue)=0
virtual void endObject()=0
virtual void visitValue(bool boolValue)=0
BasicJsonParser(std::istream &in, IObserver &observer, const ALLOC &allocator=ALLOC())