LLVMFuzzerTestOneInput:
   19|  1.63k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   20|  1.63k|  oatpp::String input(reinterpret_cast<const char*>(data), size);
   21|  1.63k|  oatpp::parser::json::mapping::ObjectMapper mapper;
   22|  1.63k|  try {
   23|  1.63k|    mapper.readFromString<oatpp::Object<Test1>>(input);
   24|  1.63k|  } catch(...) {}
   25|       |
   26|  1.63k|  return 0;
   27|  1.63k|}

_ZN5Test118Z__CLASS_TYPE_NAMEEv:
   46|      1|  static const char* Z__CLASS_TYPE_NAME() { \
   47|      1|    return #TYPE_NAME; \
   48|      1|  } \
_ZN5Test123Z__CLASS_GET_FIELDS_MAPEv:
   50|      3|  static oatpp::data::mapping::type::BaseObject::Properties* Z__CLASS_GET_FIELDS_MAP(){ \
   51|      3|    static oatpp::data::mapping::type::BaseObject::Properties map = oatpp::data::mapping::type::BaseObject::Properties(); \
   52|      3|    return &map; \
   53|      3|  } \
_ZN5Test113getParentTypeEv:
   42|      1|  static const oatpp::Type* getParentType() { \
   43|      1|    return oatpp::Object<Z__CLASS_EXTENDED>::Class::getType(); \
   44|      1|  } \

_ZNK5oatpp4data7mapping12ObjectMapper14readFromStringINS1_4type10DTOWrapperI5Test1EEEET_RKNS4_6StringE:
  125|  1.63k|  Wrapper readFromString(const oatpp::String& str) const {
  126|  1.63k|    auto type = Wrapper::Class::getType();
  127|  1.63k|    oatpp::parser::Caret caret(str);
  128|  1.63k|    auto result = read(caret, type).template cast<Wrapper>();
  129|  1.63k|    if(result == nullptr) {
  ------------------
  |  Branch (129:8): [True: 1.63k, False: 3]
  ------------------
  130|  1.63k|      throw oatpp::parser::ParsingError(caret.getErrorMessage(), caret.getErrorCode(), caret.getPosition());
  131|  1.63k|    }
  132|      3|    return result;
  133|  1.63k|  }

_ZN5oatpp4data7mapping4type7__class6ObjectI5Test1E7getTypeEv:
  307|  8.13k|    static Type* getType() {
  308|  8.13k|      static Type* type = createType();
  309|  8.13k|      return type;
  310|  8.13k|    }
_ZN5oatpp4data7mapping4type7__class6ObjectI5Test1E10createTypeEv:
  293|      1|    static Type* createType() {
  294|      1|      Type::Info info;
  295|      1|      info.nameQualifier = T::Z__CLASS_TYPE_NAME();
  296|      1|      info.polymorphicDispatcher = new PolymorphicDispatcher();
  297|      1|      info.parent = T::getParentType();
  298|      1|      return new Type(CLASS_ID, info);
  299|      1|    }
_ZNK5oatpp4data7mapping4type7__class6ObjectI5Test1E21PolymorphicDispatcher12createObjectEv:
  257|  1.60k|      type::Void createObject() const override {
  258|  1.60k|        return type::Void(std::make_shared<T>(), getType());
  259|  1.60k|      }
_ZNK5oatpp4data7mapping4type7__class6ObjectI5Test1E21PolymorphicDispatcher13getPropertiesEv:
  261|  1.60k|      const type::BaseObject::Properties* getProperties() const override {
  262|  1.60k|        return propertiesGetter();
  263|  1.60k|      }
_ZN5oatpp4data7mapping4type7__class6ObjectI5Test1E16propertiesGetterEv:
  288|  1.60k|    static const BaseObject::Properties* propertiesGetter() {
  289|  1.60k|      static type::BaseObject::Properties* properties = initProperties();
  290|  1.60k|      return properties;
  291|  1.60k|    }
_ZN5oatpp4data7mapping4type7__class6ObjectI5Test1E14initPropertiesEv:
  269|      1|    static type::BaseObject::Properties* initProperties() {
  270|       |
  271|       |      /* initializer */
  272|      1|      T obj;
  273|       |
  274|       |      /* init parent properties */
  275|      1|      auto parentType = Object<typename T::Z__CLASS_EXTENDED>::getType();
  276|      1|      if(parentType->parent != nullptr) {
  ------------------
  |  Branch (276:10): [True: 0, False: 1]
  ------------------
  277|      0|        auto dispatcher = static_cast<const AbstractObject::PolymorphicDispatcher*>(parentType->polymorphicDispatcher);
  278|      0|        dispatcher->getProperties();
  279|      0|      }
  280|       |
  281|       |      /* extend parent properties */
  282|      1|      T::Z__CLASS_EXTEND(T::Z__CLASS::Z__CLASS_GET_FIELDS_MAP(), T::Z__CLASS_EXTENDED::Z__CLASS_GET_FIELDS_MAP());
  283|       |
  284|      1|      return T::Z__CLASS::Z__CLASS_GET_FIELDS_MAP();
  285|       |
  286|      1|    }
_ZN5oatpp4data7mapping4type7__class6ObjectINS2_3DTOEE7getTypeEv:
  307|      2|    static Type* getType() {
  308|      2|      static Type* type = createType();
  309|      2|      return type;
  310|      2|    }
_ZN5oatpp4data7mapping4type7__class6ObjectINS2_3DTOEE10createTypeEv:
  293|      1|    static Type* createType() {
  294|      1|      Type::Info info;
  295|      1|      info.nameQualifier = T::Z__CLASS_TYPE_NAME();
  296|      1|      info.polymorphicDispatcher = new PolymorphicDispatcher();
  297|      1|      info.parent = T::getParentType();
  298|      1|      return new Type(CLASS_ID, info);
  299|      1|    }
_ZN5oatpp4data7mapping4type10DTOWrapperI5Test1EeqIDnvEEbT_:
  360|  1.63k|  inline bool operator == (T){
  361|  1.63k|    return this->m_ptr.get() == nullptr;
  362|  1.63k|  }

_ZN5oatpp4data7mapping4type6StringC2EPKcl:
   77|  1.63k|  {}
_ZN5oatpp4data7mapping4type6StringC2IcvEEPKT_:
   91|  4.90k|  {}
_ZN5oatpp4data7mapping4type6StringC2Ev:
   69|  1.60k|  String() {}

_ZN5oatpp4data7mapping4type13ObjectWrapperINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_7__class6StringEEC2ERKNS4_10shared_ptrISA_EE:
  145|  11.0k|  {}
_ZN5oatpp4data7mapping4type4Type4InfoC2Ev:
  444|      4|    Info() {}
_ZN5oatpp4data7mapping4type13ObjectWrapperINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_7__class6StringEEC2Ev:
  161|  1.63k|  {}
_ZN5oatpp4data7mapping4type4VoidC2ERKNSt3__110shared_ptrIvEEPKNS2_4TypeE:
  272|  6.14k|  {}
_ZN5oatpp4data7mapping4type13ObjectWrapperIvNS2_7__class4VoidEEC2ERKNSt3__110shared_ptrIvEEPKNS2_4TypeE:
  150|  6.14k|  {}
_ZNK5oatpp4data7mapping4type13ObjectWrapperIvNS2_7__class4VoidEE4castINS2_10DTOWrapperI5Test1EEEET_v:
  558|  1.63k|Wrapper ObjectWrapper<T, Clazz>::cast() const {
  559|  1.63k|  if(!Wrapper::Class::getType()->extends(m_valueType)) {
  ------------------
  |  Branch (559:6): [True: 1.63k, False: 3]
  ------------------
  560|  1.63k|    if(Wrapper::Class::getType() != __class::Void::getType() && m_valueType != __class::Void::getType()) {
  ------------------
  |  Branch (560:8): [True: 1.63k, False: 0]
  |  Branch (560:65): [True: 0, False: 1.63k]
  ------------------
  561|      0|      throw std::runtime_error("[oatpp::data::mapping::type::ObjectWrapper::cast()]: Error. Invalid cast "
  562|      0|                               "from '" + std::string(m_valueType->classId.name) + "' to '" +
  563|      0|                               std::string(Wrapper::Class::getType()->classId.name) + "'.");
  564|      0|    }
  565|  1.63k|  }
  566|  1.63k|  return Wrapper(std::static_pointer_cast<typename Wrapper::ObjectType>(m_ptr), Wrapper::Class::getType());
  567|  1.63k|}
_ZN5oatpp4data7mapping4type10DTOWrapperI5Test1EC2ERKNSt3__110shared_ptrIS4_EEPKNS2_4TypeE:
  582|  1.63k|  {} \
_ZN5oatpp4data7mapping4type13ObjectWrapperI5Test1NS2_7__class6ObjectIS4_EEEC2ERKNSt3__110shared_ptrIS4_EEPKNS2_4TypeE:
  150|  1.63k|  {}

_ZN5Test134Z__PROPERTY_INITIALIZER_PROXY_strFEv:
   52|  1.60k|#define OATPP_MACRO_EXPAND(X) X
_ZN5Test121Z__PROPERTY_INIT_strFEz:
   52|      1|#define OATPP_MACRO_EXPAND(X) X
_ZN5Test126Z__PROPERTY_SINGLETON_strFEv:
   52|      1|#define OATPP_MACRO_EXPAND(X) X
_ZN5Test123Z__PROPERTY_OFFSET_strFEv:
   52|      1|#define OATPP_MACRO_EXPAND(X) X

_ZN5oatpp6parser4json7mapping12Deserializer6ConfigC2Ev:
   96|  1.63k|    {}

_ZN5oatpp6parser4json7mapping10Serializer6ConfigC2Ev:
   56|  1.63k|    {}

_ZN5oatpp4base9CountableC2Ev:
   29|  6.50k|Countable::Countable() {
   30|  6.50k|#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
   31|  6.50k|  Environment::incObjects();
   32|  6.50k|#endif
   33|  6.50k|}
_ZN5oatpp4base9CountableD2Ev:
   42|  6.50k|Countable::~Countable(){
   43|  6.50k|#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
   44|  6.50k|  Environment::decObjects();
   45|  6.50k|#endif
   46|  6.50k|}

_ZN5oatpp4base11Environment10incObjectsEv:
  256|  6.50k|void Environment::incObjects(){
  257|       |
  258|  6.50k|  m_objectsCount ++;
  259|  6.50k|  m_objectsCreated ++;
  260|       |
  261|  6.50k|#ifndef OATPP_COMPAT_BUILD_NO_THREAD_LOCAL
  262|  6.50k|  m_threadLocalObjectsCount ++;
  263|  6.50k|  m_threadLocalObjectsCreated ++;
  264|  6.50k|#endif
  265|       |
  266|  6.50k|}
_ZN5oatpp4base11Environment10decObjectsEv:
  268|  6.50k|void Environment::decObjects(){
  269|       |
  270|  6.50k|  m_objectsCount --;
  271|       |
  272|  6.50k|#ifndef OATPP_COMPAT_BUILD_NO_THREAD_LOCAL
  273|  6.50k|  m_threadLocalObjectsCount --;
  274|  6.50k|#endif
  275|       |
  276|  6.50k|}

_ZN5oatpp11concurrency8SpinLockC2Ev:
   33|      4|{}

_ZN5oatpp4data7mapping12ObjectMapperC2ERKNS2_4InfoE:
   33|  1.63k|{}

_ZN5oatpp4data7mapping12ObjectMapper4InfoC2EPKc:
   56|      1|    {}

_ZN5oatpp4data7mapping4type10BaseObject3setElRKNS2_4VoidE:
   32|  4.85k|void BaseObject::set(v_int64 offset, const Void& value) {
   33|  4.85k|  Void* property = (Void*)(((v_int64) m_basePointer) + offset);
   34|  4.85k|  *property = value;
   35|  4.85k|}
_ZN5oatpp4data7mapping4type10BaseObject10Properties8pushBackEPNS3_8PropertyE:
   59|      1|BaseObject::Property* BaseObject::Properties::pushBack(Property* property) {
   60|      1|  m_map.insert({property->name, property});
   61|      1|  m_list.push_back(property);
   62|      1|  return property;
   63|      1|}
_ZN5oatpp4data7mapping4type10BaseObject10Properties12pushFrontAllEPS4_:
   65|      1|void BaseObject::Properties::pushFrontAll(Properties* properties) {
   66|      1|  m_map.insert(properties->m_map.begin(), properties->m_map.end());
   67|      1|  m_list.insert(m_list.begin(), properties->m_list.begin(), properties->m_list.end());
   68|      1|}
_ZN5oatpp4data7mapping4type10BaseObject8PropertyC2ElPKcPKNS2_4TypeE:
   77|      1|{}
_ZN5oatpp4data7mapping4type10BaseObject8Property3setEPS3_RKNS2_4VoidE:
   79|  4.85k|void BaseObject::Property::set(BaseObject* object, const Void& value) {
   80|  4.85k|  object->set(offset, value);
   81|  4.85k|}
_ZN5oatpp4data7mapping4type3DTO13getParentTypeEv:
  100|      1|const mapping::type::Type* DTO::getParentType() {
  101|      1|  return nullptr;
  102|      1|}
_ZN5oatpp4data7mapping4type3DTO18Z__CLASS_TYPE_NAMEEv:
  104|      1|const char* DTO::Z__CLASS_TYPE_NAME() {
  105|      1|  return "DTO";
  106|      1|}
_ZN5oatpp4data7mapping4type3DTO23Z__CLASS_GET_FIELDS_MAPEv:
  108|      1|oatpp::data::mapping::type::BaseObject::Properties* DTO::Z__CLASS_GET_FIELDS_MAP() {
  109|      1|  static data::mapping::type::BaseObject::Properties map;
  110|      1|  return &map;
  111|      1|}
_ZN5oatpp4data7mapping4type3DTO15Z__CLASS_EXTENDEPNS2_10BaseObject10PropertiesES6_:
  113|      1|BaseObject::Properties* DTO::Z__CLASS_EXTEND(BaseObject::Properties* properties, BaseObject::Properties* extensionProperties) {
  114|      1|  properties->pushFrontAll(extensionProperties);
  115|      1|  return properties;
  116|      1|}

_ZNK5oatpp4data7mapping4type10BaseObject10Properties6getMapEv:
  193|  1.60k|    const std::unordered_map<std::string, Property*>& getMap() const {
  194|  1.60k|      return m_map;
  195|  1.60k|    }

_ZNK5oatpp4data7mapping4type6StringdeEv:
   63|  1.63k|const std::string& String::operator*() const {
   64|  1.63k|  return this->m_ptr.operator*();
   65|  1.63k|}
_ZN5oatpp4data7mapping4type7__class6String7getTypeEv:
  128|  17.5k|  Type* String::getType(){
  129|  17.5k|    static Type type(CLASS_ID);
  130|  17.5k|    return &type;
  131|  17.5k|  }

_ZN5oatpp4data7mapping4type6StringC2El:
   73|  4.50k|  {}
_ZN5oatpp4data7mapping4type6StringC2ERKS3_:
  119|  1.63k|  {}
_ZN5oatpp4data7mapping4type6StringC2EOS3_:
  123|  4.50k|  {}
_ZN5oatpp4data7mapping4type6StringC2IDnvEET_:
   82|     34|  String(T) {}

_ZN5oatpp4data7mapping4type7__class4Void7getTypeEv:
   33|  4.89k|  Type* Void::getType(){
   34|  4.89k|    static Type type(CLASS_ID);
   35|  4.89k|    return &type;
   36|  4.89k|  }
_ZN5oatpp4data7mapping4type7ClassId13getClassMutexEv:
   43|  3.31k|std::mutex& ClassId::getClassMutex() {
   44|  3.31k|  static std::mutex classMutex;
   45|  3.31k|  return classMutex;
   46|  3.31k|}
_ZN5oatpp4data7mapping4type7ClassId13getClassNamesEv:
   48|  3.35k|std::vector<const char*>& ClassId::getClassNames() {
   49|  3.35k|  static std::vector<const char*> classNames;
   50|  3.35k|  return classNames;
   51|  3.35k|}
_ZN5oatpp4data7mapping4type7ClassId17registerClassNameEPKc:
   53|     42|v_int32 ClassId::registerClassName(const char* name) {
   54|     42|  std::lock_guard<std::mutex> lock(getClassMutex());
   55|     42|  getClassNames().push_back(name);
   56|     42|  return (v_int32) getClassNames().size() - 1;
   57|     42|}
_ZN5oatpp4data7mapping4type7ClassIdC2EPKc:
   62|     42|{}
_ZN5oatpp4data7mapping4type7ClassId13getClassCountEv:
   64|  3.27k|int ClassId::getClassCount() {
   65|  3.27k|  std::lock_guard<std::mutex> lock(getClassMutex());
   66|  3.27k|  return (int) getClassNames().size();
   67|  3.27k|}
_ZN5oatpp4data7mapping4type4TypeC2ERKNS2_7ClassIdERKNS3_4InfoE:
   86|      4|{}
_ZNK5oatpp4data7mapping4type4Type7extendsEPKS3_:
   98|  1.63k|bool Type::extends(const Type* other) const {
   99|  1.63k|  const Type* curr = this;
  100|  4.89k|  while(curr != nullptr) {
  ------------------
  |  Branch (100:9): [True: 3.26k, False: 1.63k]
  ------------------
  101|  3.26k|    if(curr == other) {
  ------------------
  |  Branch (101:8): [True: 3, False: 3.26k]
  ------------------
  102|      3|      return true;
  103|      3|    }
  104|  3.26k|    curr = curr->parent;
  105|  3.26k|  }
  106|  1.63k|  return false;
  107|  1.63k|}

_ZN5oatpp4data7mapping4type4VoidC2EPKNS2_4TypeE:
  284|    314|  {}
_ZN5oatpp4data7mapping4type4VoidC2EOS3_:
  300|      3|  {}
_ZN5oatpp4data7mapping4type4VoidaSERKS3_:
  320|  4.85k|  inline Void& operator = (const Void& other){
  321|  4.85k|    m_ptr = other.m_ptr;
  322|  4.85k|    m_valueType = other.getValueType();
  323|  4.85k|    return *this;
  324|  4.85k|  }
_ZNK5oatpp4data7mapping4type13ObjectWrapperIvNS2_7__class4VoidEE6getPtrEv:
  234|      3|  std::shared_ptr<T> getPtr() const {
  235|      3|    return m_ptr;
  236|      3|  }
_ZNK5oatpp4data7mapping4type13ObjectWrapperIvNS2_7__class4VoidEE12getValueTypeEv:
  262|  4.86k|  const Type* getValueType() const {
  263|  4.86k|    return m_valueType;
  264|  4.86k|  }
_ZNK5oatpp4data7mapping4type13ObjectWrapperIvNS2_7__class4VoidEE3getEv:
  226|  4.85k|  T* get() const {
  227|  4.85k|    return m_ptr.get();
  228|  4.85k|  }
_ZNK5oatpp4data7mapping4type13ObjectWrapperINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_7__class6StringEEptEv:
  222|  7.77k|  inline T* operator->() const {
  223|  7.77k|    return m_ptr.operator->();
  224|  7.77k|  }
_ZN5oatpp4data7mapping4type13ObjectWrapperIvNS2_7__class4VoidEEC2EONSt3__110shared_ptrIvEEPKNS2_4TypeE:
  155|      3|  {}
_ZNK5oatpp4data7mapping4type13ObjectWrapperINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_7__class6StringEE6getPtrEv:
  234|  6.17k|  std::shared_ptr<T> getPtr() const {
  235|  6.17k|    return m_ptr;
  236|  6.17k|  }
_ZN5oatpp4data7mapping4type13ObjectWrapperINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_7__class6StringEEC2ERKSD_:
  174|  1.63k|  {}
_ZN5oatpp4data7mapping4type13ObjectWrapperIvNS2_7__class4VoidEEC2EPKNS2_4TypeE:
  169|    314|  {}
_ZN5oatpp4data7mapping4type13ObjectWrapperINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_7__class6StringEEC2EOSD_:
  179|  4.50k|  {}
_ZN5oatpp4data7mapping4type4VoidC2IDnvEET_:
  280|  1.63k|  Void(T) {}
_ZN5oatpp4data7mapping4type13ObjectWrapperIvNS2_7__class4VoidEEC2Ev:
  161|  1.63k|  {}

_ZN5oatpp4data5share21LazyStringMapTemplateINS1_14StringKeyLabelENSt3__113unordered_mapIS3_S3_NS4_4hashIS3_EENS4_8equal_toIS3_EENS4_9allocatorINS4_4pairIKS3_S3_EEEEEEEC2Ev:
   56|      4|  {}

_ZN5oatpp4data6stream25DefaultInitializedContextC2ENS1_10StreamTypeE:
  264|      4|{}

_ZN5oatpp4data6stream7ContextC2Ev:
   77|      4|  Context() = default;

_ZN5oatpp6parser5CaretC2EPKcl:
  137|  1.63k|  {}
_ZN5oatpp6parser5CaretC2ERKNS_4data7mapping4type6StringE:
  141|  1.63k|  {
  142|  1.63k|    m_dataMemoryHandle = str.getPtr();
  143|  1.63k|  }
_ZN5oatpp6parser5CaretD2Ev:
  157|  1.63k|  Caret::~Caret(){
  158|  1.63k|  }
_ZN5oatpp6parser5Caret7getDataEv:
  160|  25.6k|  const char* Caret::getData(){
  161|  25.6k|    return m_data;
  162|  25.6k|  }
_ZN5oatpp6parser5Caret11getDataSizeEv:
  168|  25.8k|  v_buff_size Caret::getDataSize(){
  169|  25.8k|    return m_size;
  170|  25.8k|  }
_ZN5oatpp6parser5Caret11setPositionEl:
  176|  25.3k|  void Caret::setPosition(v_buff_size position){
  177|  25.3k|    m_pos = position;
  178|  25.3k|  }
_ZN5oatpp6parser5Caret11getPositionEv:
  180|  45.2k|  v_buff_size Caret::getPosition(){
  181|  45.2k|    return m_pos;
  182|  45.2k|  }
_ZN5oatpp6parser5Caret8setErrorEPKcl:
  184|  1.63k|  void Caret::setError(const char* errorMessage, v_int64 errorCode){
  185|  1.63k|    m_errorMessage = errorMessage;
  186|  1.63k|    m_errorCode = errorCode;
  187|  1.63k|  }
_ZN5oatpp6parser5Caret15getErrorMessageEv:
  189|  1.63k|  const char* Caret::getErrorMessage() {
  190|  1.63k|    return m_errorMessage;
  191|  1.63k|  }
_ZN5oatpp6parser5Caret12getErrorCodeEv:
  193|  1.63k|  v_int64 Caret::getErrorCode() {
  194|  1.63k|    return m_errorCode;
  195|  1.63k|  }
_ZN5oatpp6parser5Caret8hasErrorEv:
  197|  14.0k|  bool Caret::hasError() {
  198|  14.0k|    return m_errorMessage != nullptr;
  199|  14.0k|  }
_ZN5oatpp6parser5Caret14skipBlankCharsEv:
  218|  53.5k|  bool Caret::skipBlankChars(){
  219|       |    
  220|  55.9k|    while(m_pos < m_size){
  ------------------
  |  Branch (220:11): [True: 54.9k, False: 995]
  ------------------
  221|  54.9k|      char a = m_data[m_pos];
  222|  54.9k|      if(a != ' ' && a != '\t' && a != '\n' && a != '\r' && a != '\f')
  ------------------
  |  Branch (222:10): [True: 54.5k, False: 403]
  |  Branch (222:22): [True: 54.0k, False: 485]
  |  Branch (222:35): [True: 53.6k, False: 407]
  |  Branch (222:48): [True: 53.0k, False: 586]
  |  Branch (222:61): [True: 52.5k, False: 467]
  ------------------
  223|  52.5k|        return true;
  224|  2.34k|      m_pos ++;
  225|  2.34k|    }
  226|       |    
  227|    995|    return false;
  228|  53.5k|  }
_ZN5oatpp6parser5Caret8isAtTextEPKcb:
  397|  6.49k|  bool Caret::isAtText(const char* text, bool skipIfTrue){
  398|  6.49k|    return isAtText(text, std::strlen(text), skipIfTrue);
  399|  6.49k|  }
_ZN5oatpp6parser5Caret8isAtTextEPKclb:
  401|  6.49k|  bool Caret::isAtText(const char* text, v_buff_size textSize, bool skipIfTrue){
  402|       |    
  403|  6.49k|    if(textSize <= m_size - m_pos){
  ------------------
  |  Branch (403:8): [True: 6.35k, False: 138]
  ------------------
  404|       |      
  405|  7.61k|      for(v_buff_size i = 0; i < textSize; i++){
  ------------------
  |  Branch (405:30): [True: 7.30k, False: 314]
  ------------------
  406|       |        
  407|  7.30k|        if(text[i] != m_data[m_pos + i]){
  ------------------
  |  Branch (407:12): [True: 6.04k, False: 1.26k]
  ------------------
  408|  6.04k|          return false;
  409|  6.04k|        }
  410|       |        
  411|  7.30k|      }
  412|       |
  413|    314|      if(skipIfTrue) {
  ------------------
  |  Branch (413:10): [True: 314, False: 0]
  ------------------
  414|    314|        m_pos = m_pos + textSize;
  415|    314|      }
  416|       |      
  417|    314|      return true;
  418|       |      
  419|  6.35k|    }else{
  420|    138|      return false;
  421|    138|    }
  422|       |    
  423|  6.49k|  }
_ZNK5oatpp6parser5Caret8isAtCharEc:
  521|  35.3k|  bool Caret::isAtChar(char c) const{
  522|  35.3k|    return m_data[m_pos] == c;
  523|  35.3k|  }
_ZN5oatpp6parser5Caret17canContinueAtCharEcl:
  539|  45.9k|  bool Caret::canContinueAtChar(char c, v_buff_size skipChars){
  540|       |    
  541|  45.9k|    if(m_pos < m_size && m_errorMessage == nullptr && m_data[m_pos] == c){
  ------------------
  |  Branch (541:8): [True: 44.7k, False: 1.21k]
  |  Branch (541:26): [True: 44.7k, False: 14]
  |  Branch (541:55): [True: 36.5k, False: 8.22k]
  ------------------
  542|  36.5k|      m_pos = m_pos + skipChars;
  543|  36.5k|      return true;
  544|  36.5k|    }
  545|  9.45k|    return false;
  546|  45.9k|  }
_ZNK5oatpp6parser5Caret11canContinueEv:
  548|  14.0k|  bool Caret::canContinue() const{
  549|  14.0k|    return m_pos < m_size && m_errorMessage == nullptr;
  ------------------
  |  Branch (549:12): [True: 13.8k, False: 288]
  |  Branch (549:30): [True: 13.8k, False: 7]
  ------------------
  550|  14.0k|  }

_ZN5oatpp6parser12ParsingErrorC2ERKNS_4data7mapping4type6StringEll:
   34|  1.63k|{}

_ZN5oatpp8encoding3Hex10readUInt16EPKcRt:
   51|  23.9k|v_int32 Hex::readUInt16(const char* buffer, v_uint16& value) {
   52|  23.9k|  value = 0;
   53|   119k|  for(v_int32 i = 0; i < 4; i++){
  ------------------
  |  Branch (53:22): [True: 95.7k, False: 23.9k]
  ------------------
   54|  95.7k|    v_char8 a = buffer[i];
   55|  95.7k|    if(a >= '0' && a <= '9') {
  ------------------
  |  Branch (55:8): [True: 95.7k, False: 11]
  |  Branch (55:20): [True: 49.5k, False: 46.2k]
  ------------------
   56|  49.5k|      value |= (a - '0') << ((3 - i) << 2);
   57|  49.5k|    } else if (a >= 'A' && a <= 'F') {
  ------------------
  |  Branch (57:16): [True: 46.2k, False: 14]
  |  Branch (57:28): [True: 17.4k, False: 28.7k]
  ------------------
   58|  17.4k|      value |= (a - 'A' + 10) << ((3 - i) << 2);
   59|  28.7k|    } else if (a >= 'a' && a <= 'f') {
  ------------------
  |  Branch (59:16): [True: 28.7k, False: 22]
  |  Branch (59:28): [True: 28.7k, False: 14]
  ------------------
   60|  28.7k|      value |= (a - 'a' + 10) << ((3 - i) << 2);
   61|  28.7k|    } else {
   62|     36|      return ERROR_UNKNOWN_SYMBOL;
   63|     36|    }
   64|  95.7k|  }
   65|  23.9k|  return 0;
   66|  23.9k|}
_ZN5oatpp8encoding3Hex10readUInt32EPKcRj:
   68|  12.0k|v_int32 Hex::readUInt32(const char* buffer, v_uint32& value) {
   69|  12.0k|  value = 0;
   70|   108k|  for(v_int32 i = 0; i < 8; i++){
  ------------------
  |  Branch (70:22): [True: 96.0k, False: 11.9k]
  ------------------
   71|  96.0k|    v_char8 a = buffer[i];
   72|  96.0k|    if(a >= '0' && a <= '9') {
  ------------------
  |  Branch (72:8): [True: 96.0k, False: 11]
  |  Branch (72:20): [True: 46.9k, False: 49.1k]
  ------------------
   73|  46.9k|      value |= (a - '0') << ((7 - i) << 2);
   74|  49.1k|    } else if (a >= 'A' && a <= 'F') {
  ------------------
  |  Branch (74:16): [True: 49.1k, False: 16]
  |  Branch (74:28): [True: 13.1k, False: 35.9k]
  ------------------
   75|  13.1k|      value |= (a - 'A' + 10) << ((7 - i) << 2);
   76|  35.9k|    } else if (a >= 'a' && a <= 'f') {
  ------------------
  |  Branch (76:16): [True: 35.9k, False: 23]
  |  Branch (76:28): [True: 35.9k, False: 12]
  ------------------
   77|  35.9k|      value |= (a - 'a' + 10) << ((7 - i) << 2);
   78|  35.9k|    } else {
   79|     35|      return ERROR_UNKNOWN_SYMBOL;
   80|     35|    }
   81|  96.0k|  }
   82|  11.9k|  return 0;
   83|  12.0k|}

_ZN5oatpp8encoding7Unicode32getUtf8CharSequenceLengthForCodeEj:
   61|  21.5k|v_buff_size Unicode::getUtf8CharSequenceLengthForCode(v_uint32 code){
   62|  21.5k|  if(code < 128) {
  ------------------
  |  Branch (62:6): [True: 721, False: 20.8k]
  ------------------
   63|    721|    return 1;
   64|  20.8k|  } else if(code < 0x00000800){
  ------------------
  |  Branch (64:13): [True: 2.72k, False: 18.0k]
  ------------------
   65|  2.72k|    return 2;
   66|  18.0k|  } else if(code < 0x00010000){
  ------------------
  |  Branch (66:13): [True: 10.5k, False: 7.56k]
  ------------------
   67|  10.5k|    return 3;
   68|  10.5k|  } else if(code < 0x00200000){
  ------------------
  |  Branch (68:13): [True: 3.08k, False: 4.47k]
  ------------------
   69|  3.08k|    return 4;
   70|  4.47k|  } else if(code < 0x04000000){
  ------------------
  |  Branch (70:13): [True: 1.31k, False: 3.16k]
  ------------------
   71|  1.31k|    return 5;
   72|  3.16k|  } else {
   73|  3.16k|    return 6;
   74|  3.16k|  }
   75|  21.5k|}
_ZN5oatpp8encoding7Unicode14decodeUtf8CharEiPh:
  118|  13.5k|v_buff_size Unicode::decodeUtf8Char(v_int32 code, p_char8 buffer) {
  119|  13.5k|  if(code >= 0x00000080 && code < 0x00000800){
  ------------------
  |  Branch (119:6): [True: 11.8k, False: 1.64k]
  |  Branch (119:28): [True: 2.00k, False: 9.88k]
  ------------------
  120|  2.00k|    *((p_int16) buffer) = htons(((((code >> 6) & 31) | 192) << 8) | ((code & 63) | 128));
  121|  2.00k|    return 2;
  122|  11.5k|  } else if(code >= 0x00000800 && code < 0x00010000){
  ------------------
  |  Branch (122:13): [True: 9.88k, False: 1.64k]
  |  Branch (122:35): [True: 6.47k, False: 3.41k]
  ------------------
  123|  6.47k|    *((p_int16) buffer) = htons((((( code >> 12 ) & 15) | 224) << 8) |
  124|  6.47k|                                  (((code >>  6 ) & 63) | 128));
  125|  6.47k|    buffer[2] = (code & 63) | 128;
  126|  6.47k|    return 3;
  127|  6.47k|  } else if(code >= 0x00010000 && code < 0x00200000){
  ------------------
  |  Branch (127:13): [True: 3.41k, False: 1.64k]
  |  Branch (127:35): [True: 2.07k, False: 1.34k]
  ------------------
  128|  2.07k|    *((p_int32) buffer) = htonl(((((code >> 18 ) &  7) | 240) << 24) |
  129|  2.07k|                                ((((code >> 12 ) & 63) | 128) << 16) |
  130|  2.07k|                                ((((code >>  6 ) & 63) | 128) <<  8) |
  131|  2.07k|                                 (( code         & 63) | 128)      );
  132|  2.07k|    return 4;
  133|  2.98k|  } else if(code >= 0x00200000 && code < 0x04000000){
  ------------------
  |  Branch (133:13): [True: 1.34k, False: 1.64k]
  |  Branch (133:35): [True: 713, False: 628]
  ------------------
  134|    713|    *((p_int32) buffer) = htonl(((((code >> 24 ) &  3) | 248) << 24) |
  135|    713|                                ((((code >> 18 ) & 63) | 128) << 16) |
  136|    713|                                ((((code >> 12 ) & 63) | 128) <<  8) |
  137|    713|                                 (((code >>  6 ) & 63) | 128));
  138|    713|    buffer[4] = (code & 63) | 128;
  139|    713|    return 5;
  140|  2.27k|  } else if(code >= 0x04000000){
  ------------------
  |  Branch (140:13): [True: 628, False: 1.64k]
  ------------------
  141|    628|    *((p_int32) buffer) = htonl(((((code >> 30 ) &  1) | 252) << 24) |
  142|    628|                                ((((code >> 24 ) & 63) | 128) << 16) |
  143|    628|                                ((((code >> 18 ) & 63) | 128) <<  8) |
  144|    628|                                 (((code >> 12 ) & 63) | 128));
  145|    628|    *((p_int16) &buffer[4]) = htons(((((code >> 6 ) & 63) | 128) << 8) | (code & 63));
  146|    628|    return 6;
  147|    628|  }
  148|  1.64k|  buffer[0] = v_char8(code);
  149|  1.64k|  return 1;
  150|  13.5k|}
_ZN5oatpp8encoding7Unicode24utf16SurrogatePairToCodeEss:
  158|    794|v_int32 Unicode::utf16SurrogatePairToCode(v_int16 high, v_int16 low){
  159|    794|  return (((low - 0xDC00) & 1023) | (((high - 0xD800) & 1023) << 10)) + 0x010000;
  160|    794|}

_ZN5oatpp6parser4json5Utils23calcUnescapedStringSizeEPKclRlS5_:
   99|  17.9k|v_buff_size Utils::calcUnescapedStringSize(const char* data, v_buff_size size, v_int64& errorCode, v_buff_size& errorPosition) {
  100|  17.9k|  errorCode = 0;
  101|  17.9k|  v_buff_size result = 0;
  102|  17.9k|  v_buff_size i = 0;
  103|       |  
  104|  27.6M|  while (i < size) {
  ------------------
  |  Branch (104:10): [True: 27.6M, False: 17.6k]
  ------------------
  105|  27.6M|    v_char8 a = data[i];
  106|  27.6M|    if(a == '\\'){
  ------------------
  |  Branch (106:8): [True: 36.8k, False: 27.6M]
  ------------------
  107|       |      
  108|  36.8k|      if(i + 1 == size){
  ------------------
  |  Branch (108:10): [True: 0, False: 36.8k]
  ------------------
  109|      0|        errorCode = ERROR_CODE_INVALID_ESCAPED_CHAR;
  110|      0|        errorPosition = i;
  111|      0|        return 0;
  112|      0|      }
  113|       |      
  114|  36.8k|      v_char8 b = data[i + 1];
  115|       |      
  116|  36.8k|      if(b == '"' || b == '\\' || b == '/' || b == 'b' || b == 'f' || b == 'n' || b == 'r' || b == 't'){
  ------------------
  |  Branch (116:10): [True: 1.84k, False: 34.9k]
  |  Branch (116:22): [True: 1.11k, False: 33.8k]
  |  Branch (116:35): [True: 679, False: 33.1k]
  |  Branch (116:47): [True: 3.12k, False: 30.0k]
  |  Branch (116:59): [True: 2.42k, False: 27.6k]
  |  Branch (116:71): [True: 578, False: 27.0k]
  |  Branch (116:83): [True: 3.03k, False: 24.0k]
  |  Branch (116:95): [True: 2.27k, False: 21.7k]
  ------------------
  117|  15.0k|        result += 1;
  118|  15.0k|        i += 2;
  119|  21.7k|      } else if(b == 'u'){
  ------------------
  |  Branch (119:17): [True: 21.6k, False: 55]
  ------------------
  120|       |        
  121|  21.6k|        if(i + 6 > size){
  ------------------
  |  Branch (121:12): [True: 16, False: 21.6k]
  ------------------
  122|     16|          errorCode = ERROR_CODE_INVALID_ESCAPED_CHAR;
  123|     16|          errorPosition = i;
  124|     16|          return 0;
  125|     16|        }
  126|       |        
  127|  21.6k|        if(data[i + 2] == '+') { // not JSON standard case
  ------------------
  |  Branch (127:12): [True: 7.61k, False: 14.0k]
  ------------------
  128|  7.61k|          if(i + 11 > size){
  ------------------
  |  Branch (128:14): [True: 23, False: 7.58k]
  ------------------
  129|     23|            errorCode = ERROR_CODE_INVALID_ESCAPED_CHAR;
  130|     23|            errorPosition = i;
  131|     23|            return 0;
  132|     23|          }
  133|  7.58k|          v_uint32 code;
  134|  7.58k|          errorCode = encoding::Hex::readUInt32(&data[i + 3], code);
  135|  7.58k|          if(errorCode != 0){
  ------------------
  |  Branch (135:14): [True: 35, False: 7.55k]
  ------------------
  136|     35|            errorPosition = i + 3;
  137|     35|            return 0;
  138|     35|          }
  139|  7.55k|          i += 11;
  140|  7.55k|          result += encoding::Unicode::getUtf8CharSequenceLengthForCode(code);
  141|  14.0k|        } else {
  142|  14.0k|          v_uint16 code;
  143|  14.0k|          errorCode = encoding::Hex::readUInt16(&data[i + 2], code);
  144|  14.0k|          if(errorCode != 0){
  ------------------
  |  Branch (144:14): [True: 34, False: 14.0k]
  ------------------
  145|     34|            errorPosition = i + 2;
  146|     34|            return 0;
  147|     34|          }
  148|       |          
  149|  14.0k|          if(code >= 0xD800 && code <= 0xDBFF){
  ------------------
  |  Branch (149:14): [True: 4.85k, False: 9.17k]
  |  Branch (149:32): [True: 463, False: 4.39k]
  ------------------
  150|    463|            if(i + 12 > size){
  ------------------
  |  Branch (150:16): [True: 39, False: 424]
  ------------------
  151|     39|              errorCode = ERROR_CODE_INVALID_SURROGATE_PAIR;
  152|     39|              errorPosition = i;
  153|     39|              return 0;
  154|     39|            }
  155|    424|            v_uint16 low;
  156|    424|            errorCode = encoding::Hex::readUInt16(&data[i + 8], low);
  157|    424|            if(errorCode != 0){
  ------------------
  |  Branch (157:16): [True: 2, False: 422]
  ------------------
  158|      2|              errorPosition = i + 8;
  159|      2|              return 0;
  160|      2|            }
  161|       |            
  162|    422|            if(low >= 0xDC00 && low <= 0xDFFF){
  ------------------
  |  Branch (162:16): [True: 420, False: 2]
  |  Branch (162:33): [True: 419, False: 1]
  ------------------
  163|    419|              v_uint32 bigCode = encoding::Unicode::utf16SurrogatePairToCode(code, low);
  164|    419|              i += 12;
  165|    419|              result += encoding::Unicode::getUtf8CharSequenceLengthForCode(bigCode);
  166|    419|            } else {
  167|      3|              errorCode = ERROR_CODE_INVALID_SURROGATE_PAIR;
  168|      3|              errorPosition = i;
  169|      3|              return 0;
  170|      3|            }
  171|       |            
  172|  13.5k|          } else {
  173|  13.5k|            i += 6;
  174|  13.5k|            result += encoding::Unicode::getUtf8CharSequenceLengthForCode(code);
  175|  13.5k|          }
  176|  14.0k|        }
  177|       |        
  178|  21.6k|      } else {
  179|     55|        errorCode = ERROR_CODE_INVALID_ESCAPED_CHAR;
  180|     55|        errorPosition = i;
  181|     55|        return 0;
  182|     55|      }
  183|       |      
  184|  27.6M|    } else {
  185|  27.6M|      i ++;
  186|  27.6M|      result ++;
  187|  27.6M|    }
  188|       |    
  189|  27.6M|  }
  190|       |  
  191|  17.6k|  return result;
  192|  17.9k|}
_ZN5oatpp6parser4json5Utils22unescapeStringToBufferEPKclPh:
  315|  1.82k|void Utils::unescapeStringToBuffer(const char* data, v_buff_size size, p_char8 resultData){
  316|       |  
  317|  1.82k|  v_buff_size i = 0;
  318|  1.82k|  v_buff_size pos = 0;
  319|       |  
  320|  12.3M|  while (i < size) {
  ------------------
  |  Branch (320:10): [True: 12.3M, False: 1.82k]
  ------------------
  321|  12.3M|    v_char8 a = data[i];
  322|       |    
  323|  12.3M|    if(a == '\\'){
  ------------------
  |  Branch (323:8): [True: 22.6k, False: 12.3M]
  ------------------
  324|  22.6k|      v_char8 b = data[i + 1];
  325|  22.6k|      if(b != 'u'){
  ------------------
  |  Branch (325:10): [True: 9.16k, False: 13.5k]
  ------------------
  326|  9.16k|        switch (b) {
  ------------------
  |  Branch (326:17): [True: 0, False: 9.16k]
  ------------------
  327|  1.27k|          case '"': resultData[pos] = '"'; pos ++; break;
  ------------------
  |  Branch (327:11): [True: 1.27k, False: 7.89k]
  ------------------
  328|    818|          case '\\': resultData[pos] = '\\'; pos ++; break;
  ------------------
  |  Branch (328:11): [True: 818, False: 8.34k]
  ------------------
  329|    667|          case '/': resultData[pos] = '/'; pos ++; break;
  ------------------
  |  Branch (329:11): [True: 667, False: 8.49k]
  ------------------
  330|  1.46k|          case 'b': resultData[pos] = '\b'; pos ++; break;
  ------------------
  |  Branch (330:11): [True: 1.46k, False: 7.69k]
  ------------------
  331|    686|          case 'f': resultData[pos] = '\f'; pos ++; break;
  ------------------
  |  Branch (331:11): [True: 686, False: 8.47k]
  ------------------
  332|    573|          case 'n': resultData[pos] = '\n'; pos ++; break;
  ------------------
  |  Branch (332:11): [True: 573, False: 8.59k]
  ------------------
  333|  1.96k|          case 'r': resultData[pos] = '\r'; pos ++; break;
  ------------------
  |  Branch (333:11): [True: 1.96k, False: 7.19k]
  ------------------
  334|  1.71k|          case 't': resultData[pos] = '\t'; pos ++; break;
  ------------------
  |  Branch (334:11): [True: 1.71k, False: 7.45k]
  ------------------
  335|  9.16k|        }
  336|  9.16k|        i += 2;
  337|  13.5k|      } else {
  338|  13.5k|        if(data[i + 2] == '+'){ // Not JSON standard case
  ------------------
  |  Branch (338:12): [True: 4.43k, False: 9.09k]
  ------------------
  339|  4.43k|          v_uint32 code;
  340|  4.43k|          encoding::Hex::readUInt32(&data[i + 3], code);
  341|  4.43k|          i += 11;
  342|  4.43k|          pos += encoding::Unicode::decodeUtf8Char(code, &resultData[pos]);
  343|  9.09k|        } else {
  344|       |          
  345|  9.09k|          v_uint16 code;
  346|  9.09k|          encoding::Hex::readUInt16(&data[i + 2], code);
  347|       |          
  348|  9.09k|          if(code >= 0xD800 && code <= 0xDBFF){
  ------------------
  |  Branch (348:14): [True: 2.90k, False: 6.18k]
  |  Branch (348:32): [True: 375, False: 2.53k]
  ------------------
  349|    375|            v_uint16 low;
  350|    375|            encoding::Hex::readUInt16(&data[i + 8], low);
  351|    375|            v_uint32 bigCode = encoding::Unicode::utf16SurrogatePairToCode(code, low);
  352|    375|            pos += encoding::Unicode::decodeUtf8Char(bigCode, &resultData[pos]);
  353|    375|            i += 12;
  354|  8.71k|          } else {
  355|  8.71k|            pos += encoding::Unicode::decodeUtf8Char(code, &resultData[pos]);
  356|  8.71k|            i += 6;
  357|  8.71k|          }
  358|       |          
  359|  9.09k|        }
  360|  13.5k|      }
  361|  12.3M|    } else {
  362|  12.3M|      resultData[pos] = a;
  363|  12.3M|      pos ++;
  364|  12.3M|      i++;
  365|  12.3M|    }
  366|       |    
  367|  12.3M|  }
  368|       |  
  369|  1.82k|}
_ZN5oatpp6parser4json5Utils14unescapeStringEPKclRlS5_:
  371|  4.51k|oatpp::String Utils::unescapeString(const char* data, v_buff_size size, v_int64& errorCode, v_buff_size& errorPosition) {
  372|       |  
  373|  4.51k|  v_buff_size unescapedSize = calcUnescapedStringSize(data, size, errorCode, errorPosition);
  374|  4.51k|  if(errorCode != 0){
  ------------------
  |  Branch (374:6): [True: 2, False: 4.50k]
  ------------------
  375|      2|    return nullptr;
  376|      2|  }
  377|  4.50k|  auto result = String(unescapedSize);
  378|  4.50k|  if(unescapedSize == size) {
  ------------------
  |  Branch (378:6): [True: 4.09k, False: 410]
  ------------------
  379|  4.09k|    std::memcpy((void*) result->data(), data, size);
  380|  4.09k|  } else {
  381|    410|    unescapeStringToBuffer(data, size, (p_char8) result->data());
  382|    410|  }
  383|  4.50k|  return result;
  384|       |  
  385|  4.51k|}
_ZN5oatpp6parser4json5Utils25unescapeStringToStdStringEPKclRlS5_:
  387|  13.3k|std::string Utils::unescapeStringToStdString(const char* data, v_buff_size size, v_int64& errorCode, v_buff_size& errorPosition){
  388|       |  
  389|  13.3k|  v_buff_size unescapedSize = calcUnescapedStringSize(data, size, errorCode, errorPosition);
  390|  13.3k|  if(errorCode != 0){
  ------------------
  |  Branch (390:6): [True: 205, False: 13.1k]
  ------------------
  391|    205|    return "";
  392|    205|  }
  393|  13.1k|  std::string result;
  394|  13.1k|  result.resize(unescapedSize);
  395|  13.1k|  if(unescapedSize == size) {
  ------------------
  |  Branch (395:6): [True: 11.7k, False: 1.41k]
  ------------------
  396|  11.7k|    std::memcpy((p_char8) result.data(), data, size);
  397|  11.7k|  } else {
  398|  1.41k|    unescapeStringToBuffer(data, size, (p_char8) result.data());
  399|  1.41k|  }
  400|  13.1k|  return result;
  401|       |  
  402|  13.3k|}
_ZN5oatpp6parser4json5Utils14preparseStringERNS0_5CaretERl:
  404|  18.3k|const char* Utils::preparseString(ParsingCaret& caret, v_buff_size& size){
  405|       |  
  406|  18.3k|  if(caret.canContinueAtChar('"', 1)){
  ------------------
  |  Branch (406:6): [True: 18.0k, False: 306]
  ------------------
  407|       |    
  408|  18.0k|    const char* data = caret.getData();
  409|  18.0k|    v_buff_size pos = caret.getPosition();
  410|  18.0k|    v_buff_size pos0 = pos;
  411|  18.0k|    v_buff_size length = caret.getDataSize();
  412|       |    
  413|  29.1M|    while (pos < length) {
  ------------------
  |  Branch (413:12): [True: 29.1M, False: 137]
  ------------------
  414|  29.1M|      v_char8 a = data[pos];
  415|  29.1M|      if(a == '"'){
  ------------------
  |  Branch (415:10): [True: 17.9k, False: 29.1M]
  ------------------
  416|  17.9k|        size = pos - pos0;
  417|  17.9k|        return &data[pos0];
  418|  29.1M|      } else if(a == '\\') {
  ------------------
  |  Branch (418:17): [True: 37.5k, False: 29.0M]
  ------------------
  419|  37.5k|        pos += 2;
  420|  29.0M|      } else {
  421|  29.0M|        pos ++;
  422|  29.0M|      }
  423|  29.1M|    }
  424|    137|    caret.setPosition(caret.getDataSize());
  425|    137|    caret.setError("[oatpp::parser::json::Utils::preparseString()]: Error. '\"' - expected", ERROR_CODE_PARSER_QUOTE_EXPECTED);
  426|    306|  } else {
  427|    306|    caret.setError("[oatpp::parser::json::Utils::preparseString()]: Error. '\"' - expected", ERROR_CODE_PARSER_QUOTE_EXPECTED);
  428|    306|  }
  429|       |  
  430|    443|  return nullptr;
  431|       |  
  432|  18.3k|}
_ZN5oatpp6parser4json5Utils11parseStringERNS0_5CaretE:
  434|  4.54k|oatpp::String Utils::parseString(ParsingCaret& caret) {
  435|       |  
  436|  4.54k|  v_buff_size size;
  437|  4.54k|  const char* data = preparseString(caret, size);
  438|       |  
  439|  4.54k|  if(data != nullptr) {
  ------------------
  |  Branch (439:6): [True: 4.51k, False: 32]
  ------------------
  440|       |  
  441|  4.51k|    v_buff_size pos = caret.getPosition();
  442|       |    
  443|  4.51k|    v_int64 errorCode;
  444|  4.51k|    v_buff_size errorPosition;
  445|  4.51k|    auto result = unescapeString(data, size, errorCode, errorPosition);
  446|  4.51k|    if(errorCode != 0){
  ------------------
  |  Branch (446:8): [True: 2, False: 4.50k]
  ------------------
  447|      2|      caret.setError("[oatpp::parser::json::Utils::parseString()]: Error. Call to unescapeString() failed", errorCode);
  448|      2|      caret.setPosition(pos + errorPosition);
  449|  4.50k|    } else {
  450|  4.50k|      caret.setPosition(pos + size + 1);
  451|  4.50k|    }
  452|       |    
  453|  4.51k|    return result;
  454|       |    
  455|  4.51k|  }
  456|       |  
  457|     32|  return nullptr;
  458|       |  
  459|  4.54k|}
_ZN5oatpp6parser4json5Utils22parseStringToStdStringERNS0_5CaretE:
  461|  13.8k|std::string Utils::parseStringToStdString(ParsingCaret& caret){
  462|       |  
  463|  13.8k|  v_buff_size size;
  464|  13.8k|  auto data = preparseString(caret, size);
  465|       |  
  466|  13.8k|  if(data != nullptr) {
  ------------------
  |  Branch (466:6): [True: 13.3k, False: 411]
  ------------------
  467|       |    
  468|  13.3k|    v_buff_size pos = caret.getPosition();
  469|       |    
  470|  13.3k|    v_int64 errorCode;
  471|  13.3k|    v_buff_size errorPosition;
  472|  13.3k|    const std::string& result = unescapeStringToStdString(data, size, errorCode, errorPosition);
  473|  13.3k|    if(errorCode != 0){
  ------------------
  |  Branch (473:8): [True: 205, False: 13.1k]
  ------------------
  474|    205|      caret.setError("[oatpp::parser::json::Utils::parseStringToStdString()]: Error. Call to unescapeStringToStdString() failed", errorCode);
  475|    205|      caret.setPosition(pos + errorPosition);
  476|  13.1k|    } else {
  477|  13.1k|      caret.setPosition(pos + size + 1);
  478|  13.1k|    }
  479|       |    
  480|  13.3k|    return result;
  481|       |    
  482|  13.3k|  }
  483|       |  
  484|    411|  return "";
  485|       |  
  486|  13.8k|}

_ZN5oatpp6parser4json7mapping12DeserializerC2ERKNSt3__110shared_ptrINS3_6ConfigEEE:
   33|  1.63k|{
   34|       |
   35|  1.63k|  m_methods.resize(data::mapping::type::ClassId::getClassCount(), nullptr);
   36|       |
   37|  1.63k|  setDeserializerMethod(data::mapping::type::__class::String::CLASS_ID, &Deserializer::deserializeString);
   38|  1.63k|  setDeserializerMethod(data::mapping::type::__class::Any::CLASS_ID, &Deserializer::deserializeAny);
   39|       |
   40|  1.63k|  setDeserializerMethod(data::mapping::type::__class::Int8::CLASS_ID, &Deserializer::deserializeInt<oatpp::Int8>);
   41|  1.63k|  setDeserializerMethod(data::mapping::type::__class::UInt8::CLASS_ID, &Deserializer::deserializeUInt<oatpp::UInt8>);
   42|       |
   43|  1.63k|  setDeserializerMethod(data::mapping::type::__class::Int16::CLASS_ID, &Deserializer::deserializeInt<oatpp::Int16>);
   44|  1.63k|  setDeserializerMethod(data::mapping::type::__class::UInt16::CLASS_ID, &Deserializer::deserializeUInt<oatpp::UInt16>);
   45|       |
   46|  1.63k|  setDeserializerMethod(data::mapping::type::__class::Int32::CLASS_ID, &Deserializer::deserializeInt<oatpp::Int32>);
   47|  1.63k|  setDeserializerMethod(data::mapping::type::__class::UInt32::CLASS_ID, &Deserializer::deserializeUInt<oatpp::UInt32>);
   48|       |
   49|  1.63k|  setDeserializerMethod(data::mapping::type::__class::Int64::CLASS_ID, &Deserializer::deserializeInt<oatpp::Int64>);
   50|  1.63k|  setDeserializerMethod(data::mapping::type::__class::UInt64::CLASS_ID, &Deserializer::deserializeUInt<oatpp::UInt64>);
   51|       |
   52|  1.63k|  setDeserializerMethod(data::mapping::type::__class::Float32::CLASS_ID, &Deserializer::deserializeFloat32);
   53|  1.63k|  setDeserializerMethod(data::mapping::type::__class::Float64::CLASS_ID, &Deserializer::deserializeFloat64);
   54|  1.63k|  setDeserializerMethod(data::mapping::type::__class::Boolean::CLASS_ID, &Deserializer::deserializeBoolean);
   55|       |
   56|  1.63k|  setDeserializerMethod(data::mapping::type::__class::AbstractObject::CLASS_ID, &Deserializer::deserializeObject);
   57|  1.63k|  setDeserializerMethod(data::mapping::type::__class::AbstractEnum::CLASS_ID, &Deserializer::deserializeEnum);
   58|       |
   59|  1.63k|  setDeserializerMethod(data::mapping::type::__class::AbstractVector::CLASS_ID, &Deserializer::deserializeCollection);
   60|  1.63k|  setDeserializerMethod(data::mapping::type::__class::AbstractList::CLASS_ID, &Deserializer::deserializeCollection);
   61|  1.63k|  setDeserializerMethod(data::mapping::type::__class::AbstractUnorderedSet::CLASS_ID, &Deserializer::deserializeCollection);
   62|       |
   63|  1.63k|  setDeserializerMethod(data::mapping::type::__class::AbstractPairList::CLASS_ID, &Deserializer::deserializeMap);
   64|  1.63k|  setDeserializerMethod(data::mapping::type::__class::AbstractUnorderedMap::CLASS_ID, &Deserializer::deserializeMap);
   65|       |
   66|  1.63k|}
_ZN5oatpp6parser4json7mapping12Deserializer21setDeserializerMethodERKNS_4data7mapping4type7ClassIdEPFNS6_4VoidEPS3_RNS0_5CaretEPKNS6_4TypeEE:
   68|  32.7k|void Deserializer::setDeserializerMethod(const data::mapping::type::ClassId& classId, DeserializerMethod method) {
   69|  32.7k|  const v_uint32 id = classId.id;
   70|  32.7k|  if(id >= m_methods.size()) {
  ------------------
  |  Branch (70:6): [True: 0, False: 32.7k]
  ------------------
   71|      0|    m_methods.resize(id + 1, nullptr);
   72|      0|  }
   73|  32.7k|  m_methods[id] = method;
   74|  32.7k|}
_ZN5oatpp6parser4json7mapping12Deserializer9skipScopeERNS0_5CaretEhh:
   76|  1.09k|void Deserializer::skipScope(oatpp::parser::Caret& caret, v_char8 charOpen, v_char8 charClose){
   77|       |
   78|  1.09k|  const char* data = caret.getData();
   79|  1.09k|  v_buff_size size = caret.getDataSize();
   80|  1.09k|  v_buff_size pos = caret.getPosition();
   81|  1.09k|  v_int32 scopeCounter = 0;
   82|       |
   83|  1.09k|  bool isInString = false;
   84|       |
   85|  2.74M|  while(pos < size){
  ------------------
  |  Branch (85:9): [True: 2.74M, False: 150]
  ------------------
   86|  2.74M|    v_char8 a = data[pos];
   87|  2.74M|    if(a == charOpen){
  ------------------
  |  Branch (87:8): [True: 1.06M, False: 1.68M]
  ------------------
   88|  1.06M|      if(!isInString){
  ------------------
  |  Branch (88:10): [True: 1.06M, False: 892]
  ------------------
   89|  1.06M|        scopeCounter ++;
   90|  1.06M|      }
   91|  1.68M|    } else if(a == charClose){
  ------------------
  |  Branch (91:15): [True: 3.02k, False: 1.67M]
  ------------------
   92|  3.02k|      if(!isInString){
  ------------------
  |  Branch (92:10): [True: 2.76k, False: 267]
  ------------------
   93|  2.76k|        scopeCounter --;
   94|  2.76k|        if(scopeCounter == 0){
  ------------------
  |  Branch (94:12): [True: 948, False: 1.81k]
  ------------------
   95|    948|          caret.setPosition(pos + 1);
   96|    948|          return;
   97|    948|        }
   98|  2.76k|      }
   99|  1.67M|    } else if(a == '"') {
  ------------------
  |  Branch (99:15): [True: 4.24k, False: 1.67M]
  ------------------
  100|  4.24k|      isInString = !isInString;
  101|  1.67M|    } else if(a == '\\'){
  ------------------
  |  Branch (101:15): [True: 4.64k, False: 1.66M]
  ------------------
  102|  4.64k|      pos ++;
  103|  4.64k|    }
  104|       |
  105|  2.74M|    pos ++;
  106|       |
  107|  2.74M|  }
  108|  1.09k|}
_ZN5oatpp6parser4json7mapping12Deserializer10skipStringERNS0_5CaretE:
  110|    787|void Deserializer::skipString(oatpp::parser::Caret& caret){
  111|    787|  const char* data = caret.getData();
  112|    787|  v_buff_size size = caret.getDataSize();
  113|    787|  v_buff_size pos = caret.getPosition();
  114|    787|  v_int32 scopeCounter = 0;
  115|  38.1k|  while(pos < size){
  ------------------
  |  Branch (115:9): [True: 38.0k, False: 79]
  ------------------
  116|  38.0k|    v_char8 a = data[pos];
  117|  38.0k|    if(a == '"'){
  ------------------
  |  Branch (117:8): [True: 1.49k, False: 36.5k]
  ------------------
  118|  1.49k|      scopeCounter ++;
  119|  1.49k|      if(scopeCounter == 2) {
  ------------------
  |  Branch (119:10): [True: 708, False: 787]
  ------------------
  120|    708|        caret.setPosition(pos + 1);
  121|    708|        return;
  122|    708|      }
  123|  36.5k|    } else if(a == '\\'){
  ------------------
  |  Branch (123:15): [True: 434, False: 36.1k]
  ------------------
  124|    434|      pos ++;
  125|    434|    }
  126|  37.3k|    pos ++;
  127|  37.3k|  }
  128|    787|}
_ZN5oatpp6parser4json7mapping12Deserializer9skipTokenERNS0_5CaretE:
  130|  5.75k|void Deserializer::skipToken(oatpp::parser::Caret& caret){
  131|  5.75k|  const char* data = caret.getData();
  132|  5.75k|  v_buff_size size = caret.getDataSize();
  133|  5.75k|  v_buff_size pos = caret.getPosition();
  134|  34.8k|  while(pos < size){
  ------------------
  |  Branch (134:9): [True: 34.7k, False: 95]
  ------------------
  135|  34.7k|    v_char8 a = data[pos];
  136|  34.7k|    if(a == ' ' || a == '\t' || a == '\n' || a == '\r' || a == '\b' || a == '\f' ||
  ------------------
  |  Branch (136:8): [True: 202, False: 34.5k]
  |  Branch (136:20): [True: 273, False: 34.2k]
  |  Branch (136:33): [True: 203, False: 34.0k]
  |  Branch (136:46): [True: 352, False: 33.6k]
  |  Branch (136:59): [True: 2, False: 33.6k]
  |  Branch (136:72): [True: 263, False: 33.4k]
  ------------------
  137|  34.7k|       a == '}' || a == ',' || a == ']') {
  ------------------
  |  Branch (137:8): [True: 1, False: 33.4k]
  |  Branch (137:20): [True: 4.36k, False: 29.0k]
  |  Branch (137:32): [True: 2, False: 29.0k]
  ------------------
  138|  5.66k|      caret.setPosition(pos);
  139|  5.66k|      return;
  140|  5.66k|    }
  141|  29.0k|    pos ++;
  142|  29.0k|  }
  143|  5.75k|}
_ZN5oatpp6parser4json7mapping12Deserializer9skipValueERNS0_5CaretE:
  145|  7.64k|void Deserializer::skipValue(oatpp::parser::Caret& caret){
  146|  7.64k|  if(caret.isAtChar('{')){
  ------------------
  |  Branch (146:6): [True: 589, False: 7.05k]
  ------------------
  147|    589|    skipScope(caret, '{', '}');
  148|  7.05k|  } else if(caret.isAtChar('[')){
  ------------------
  |  Branch (148:13): [True: 509, False: 6.54k]
  ------------------
  149|    509|    skipScope(caret, '[', ']');
  150|  6.54k|  } else if(caret.isAtChar('"')){
  ------------------
  |  Branch (150:13): [True: 787, False: 5.75k]
  ------------------
  151|    787|    skipString(caret);
  152|  5.75k|  } else {
  153|  5.75k|    skipToken(caret);
  154|  5.75k|  }
  155|  7.64k|}
_ZN5oatpp6parser4json7mapping12Deserializer17deserializeStringEPS3_RNS0_5CaretEPKNS_4data7mapping4type4TypeE:
  202|  4.85k|oatpp::Void Deserializer::deserializeString(Deserializer* deserializer, parser::Caret& caret, const Type* const type) {
  203|       |
  204|  4.85k|  (void) deserializer;
  205|  4.85k|  (void) type;
  206|       |
  207|  4.85k|  if(caret.isAtText("null", true)){
  ------------------
  |  Branch (207:6): [True: 314, False: 4.54k]
  ------------------
  208|    314|    return oatpp::Void(String::Class::getType());
  209|  4.54k|  } else {
  210|  4.54k|    return oatpp::Void(oatpp::parser::json::Utils::parseString(caret).getPtr(), String::Class::getType());
  211|  4.54k|  }
  212|  4.85k|}
_ZN5oatpp6parser4json7mapping12Deserializer17deserializeObjectEPS3_RNS0_5CaretEPKNS_4data7mapping4type4TypeE:
  405|  1.63k|oatpp::Void Deserializer::deserializeObject(Deserializer* deserializer, parser::Caret& caret, const Type* const type) {
  406|       |
  407|  1.63k|  if(caret.isAtText("null", true)){
  ------------------
  |  Branch (407:6): [True: 0, False: 1.63k]
  ------------------
  408|      0|    return oatpp::Void(type);
  409|      0|  }
  410|       |
  411|  1.63k|  if(caret.canContinueAtChar('{', 1)) {
  ------------------
  |  Branch (411:6): [True: 1.60k, False: 35]
  ------------------
  412|       |
  413|  1.60k|    auto dispatcher = static_cast<const oatpp::data::mapping::type::__class::AbstractObject::PolymorphicDispatcher*>(type->polymorphicDispatcher);
  414|  1.60k|    auto object = dispatcher->createObject();
  415|  1.60k|    const auto& fieldsMap = dispatcher->getProperties()->getMap();
  416|       |
  417|  1.60k|    caret.skipBlankChars();
  418|       |
  419|  1.60k|    std::vector<std::pair<oatpp::BaseObject::Property*, oatpp::String>> polymorphs;
  420|  14.0k|    while (!caret.isAtChar('}') && caret.canContinue()) {
  ------------------
  |  Branch (420:12): [True: 14.0k, False: 3]
  |  Branch (420:36): [True: 13.8k, False: 295]
  ------------------
  421|       |
  422|  13.8k|      caret.skipBlankChars();
  423|  13.8k|      auto key = Utils::parseStringToStdString(caret);
  424|  13.8k|      if(caret.hasError()){
  ------------------
  |  Branch (424:10): [True: 616, False: 13.1k]
  ------------------
  425|    616|        return nullptr;
  426|    616|      }
  427|       |
  428|  13.1k|      auto fieldIterator = fieldsMap.find(key);
  429|  13.1k|      if(fieldIterator != fieldsMap.end()){
  ------------------
  |  Branch (429:10): [True: 4.87k, False: 8.31k]
  ------------------
  430|       |
  431|  4.87k|        caret.skipBlankChars();
  432|  4.87k|        if(!caret.canContinueAtChar(':', 1)){
  ------------------
  |  Branch (432:12): [True: 13, False: 4.85k]
  ------------------
  433|     13|          caret.setError("[oatpp::parser::json::mapping::Deserializer::readObject()]: Error. ':' - expected", ERROR_CODE_OBJECT_SCOPE_COLON_MISSING);
  434|     13|          return nullptr;
  435|     13|        }
  436|       |
  437|  4.85k|        caret.skipBlankChars();
  438|       |
  439|  4.85k|        auto field = fieldIterator->second;
  440|       |
  441|  4.85k|        if(field->info.typeSelector && field->type == oatpp::Any::Class::getType()) {
  ------------------
  |  Branch (441:12): [True: 0, False: 4.85k]
  |  Branch (441:40): [True: 0, False: 0]
  ------------------
  442|      0|          auto label = caret.putLabel();
  443|      0|          skipValue(caret);
  444|      0|          polymorphs.emplace_back(field, label.toString()); // store polymorphs for later processing.
  445|  4.85k|        } else {
  446|  4.85k|          field->set(static_cast<oatpp::BaseObject *>(object.get()), deserializer->deserialize(caret, field->type));
  447|  4.85k|        }
  448|       |
  449|  8.31k|      } else if (deserializer->getConfig()->allowUnknownFields) {
  ------------------
  |  Branch (449:18): [True: 8.31k, False: 0]
  ------------------
  450|  8.31k|        caret.skipBlankChars();
  451|  8.31k|        if(!caret.canContinueAtChar(':', 1)){
  ------------------
  |  Branch (451:12): [True: 673, False: 7.64k]
  ------------------
  452|    673|          caret.setError("[oatpp::parser::json::mapping::Deserializer::readObject()/if(config->allowUnknownFields){}]: Error. ':' - expected", ERROR_CODE_OBJECT_SCOPE_COLON_MISSING);
  453|    673|          return nullptr;
  454|    673|        }
  455|  7.64k|        caret.skipBlankChars();
  456|  7.64k|        skipValue(caret);
  457|  7.64k|      } else {
  458|      0|        caret.setError("[oatpp::parser::json::mapping::Deserializer::readObject()]: Error. Unknown field", ERROR_CODE_OBJECT_SCOPE_UNKNOWN_FIELD);
  459|      0|        return nullptr;
  460|      0|      }
  461|       |
  462|  12.4k|      caret.skipBlankChars();
  463|  12.4k|      caret.canContinueAtChar(',', 1);
  464|       |
  465|  12.4k|    }
  466|       |
  467|    298|    if(!caret.canContinueAtChar('}', 1)){
  ------------------
  |  Branch (467:8): [True: 295, False: 3]
  ------------------
  468|    295|      if(!caret.hasError()){
  ------------------
  |  Branch (468:10): [True: 261, False: 34]
  ------------------
  469|    261|        caret.setError("[oatpp::parser::json::mapping::Deserializer::readObject()]: Error. '}' - expected", ERROR_CODE_OBJECT_SCOPE_CLOSE);
  470|    261|      }
  471|    295|      return nullptr;
  472|    295|    }
  473|       |
  474|      3|    for(auto& p : polymorphs) {
  ------------------
  |  Branch (474:17): [True: 0, False: 3]
  ------------------
  475|      0|      parser::Caret polyCaret(p.second);
  476|      0|      auto selectedType = p.first->info.typeSelector->selectType(static_cast<oatpp::BaseObject *>(object.get()));
  477|      0|      auto value = deserializer->deserialize(polyCaret, selectedType);
  478|      0|      oatpp::Any any(value);
  479|      0|      p.first->set(static_cast<oatpp::BaseObject *>(object.get()), oatpp::Void(any.getPtr(), p.first->type));
  480|      0|    }
  481|       |
  482|      3|    return object;
  483|       |
  484|    298|  } else {
  485|     35|    caret.setError("[oatpp::parser::json::mapping::Deserializer::readObject()]: Error. '{' - expected", ERROR_CODE_OBJECT_SCOPE_OPEN);
  486|     35|  }
  487|       |
  488|     35|  return nullptr;
  489|       |
  490|  1.63k|}
_ZN5oatpp6parser4json7mapping12Deserializer11deserializeERNS0_5CaretEPKNS_4data7mapping4type4TypeE:
  492|  6.49k|oatpp::Void Deserializer::deserialize(parser::Caret& caret, const Type* const type) {
  493|  6.49k|  auto id = type->classId.id;
  494|  6.49k|  auto& method = m_methods[id];
  495|  6.49k|  if(method) {
  ------------------
  |  Branch (495:6): [True: 6.49k, False: 0]
  ------------------
  496|  6.49k|    return (*method)(this, caret, type);
  497|  6.49k|  } else {
  498|       |
  499|      0|    auto* interpretation = type->findInterpretation(m_config->enabledInterpretations);
  500|      0|    if(interpretation) {
  ------------------
  |  Branch (500:8): [True: 0, False: 0]
  ------------------
  501|      0|      return interpretation->fromInterpretation(deserialize(caret, interpretation->getInterpretationType()));
  502|      0|    }
  503|       |
  504|      0|    throw std::runtime_error("[oatpp::parser::json::mapping::Deserializer::deserialize()]: "
  505|      0|                             "Error. No deserialize method for type '" + std::string(type->classId.name) + "'");
  506|      0|  }
  507|  6.49k|}
_ZN5oatpp6parser4json7mapping12Deserializer9getConfigEv:
  509|  8.31k|const std::shared_ptr<Deserializer::Config>& Deserializer::getConfig() {
  510|  8.31k|  return m_config;
  511|  8.31k|}

_ZN5oatpp6parser4json7mapping12ObjectMapperC2ERKNSt3__110shared_ptrINS2_10SerializerEEERKNS5_INS2_12DeserializerEEE:
   41|  1.63k|{}
_ZNK5oatpp6parser4json7mapping12ObjectMapper4readERNS0_5CaretEPKNS_4data7mapping4type4TypeE:
   59|  1.63k|                                                                     const oatpp::data::mapping::type::Type* const type) const {
   60|  1.63k|  return m_deserializer->deserialize(caret, type);
   61|  1.63k|}

_ZN5oatpp6parser4json7mapping12ObjectMapper13getMapperInfoEv:
   42|  1.63k|  static Info& getMapperInfo() {
   43|  1.63k|    static Info info("application/json");
   44|  1.63k|    return info;
   45|  1.63k|  }

_ZN5oatpp6parser4json7mapping10SerializerC2ERKNSt3__110shared_ptrINS3_6ConfigEEE:
   34|  1.63k|{
   35|       |
   36|  1.63k|  m_methods.resize(data::mapping::type::ClassId::getClassCount(), nullptr);
   37|       |
   38|  1.63k|  setSerializerMethod(data::mapping::type::__class::String::CLASS_ID, &Serializer::serializeString);
   39|  1.63k|  setSerializerMethod(data::mapping::type::__class::Any::CLASS_ID, &Serializer::serializeAny);
   40|       |
   41|  1.63k|  setSerializerMethod(data::mapping::type::__class::Int8::CLASS_ID, &Serializer::serializePrimitive<oatpp::Int8>);
   42|  1.63k|  setSerializerMethod(data::mapping::type::__class::UInt8::CLASS_ID, &Serializer::serializePrimitive<oatpp::UInt8>);
   43|       |
   44|  1.63k|  setSerializerMethod(data::mapping::type::__class::Int16::CLASS_ID, &Serializer::serializePrimitive<oatpp::Int16>);
   45|  1.63k|  setSerializerMethod(data::mapping::type::__class::UInt16::CLASS_ID, &Serializer::serializePrimitive<oatpp::UInt16>);
   46|       |
   47|  1.63k|  setSerializerMethod(data::mapping::type::__class::Int32::CLASS_ID, &Serializer::serializePrimitive<oatpp::Int32>);
   48|  1.63k|  setSerializerMethod(data::mapping::type::__class::UInt32::CLASS_ID, &Serializer::serializePrimitive<oatpp::UInt32>);
   49|       |
   50|  1.63k|  setSerializerMethod(data::mapping::type::__class::Int64::CLASS_ID, &Serializer::serializePrimitive<oatpp::Int64>);
   51|  1.63k|  setSerializerMethod(data::mapping::type::__class::UInt64::CLASS_ID, &Serializer::serializePrimitive<oatpp::UInt64>);
   52|       |
   53|  1.63k|  setSerializerMethod(data::mapping::type::__class::Float32::CLASS_ID, &Serializer::serializePrimitive<oatpp::Float32>);
   54|  1.63k|  setSerializerMethod(data::mapping::type::__class::Float64::CLASS_ID, &Serializer::serializePrimitive<oatpp::Float64>);
   55|  1.63k|  setSerializerMethod(data::mapping::type::__class::Boolean::CLASS_ID, &Serializer::serializePrimitive<oatpp::Boolean>);
   56|       |
   57|  1.63k|  setSerializerMethod(data::mapping::type::__class::AbstractObject::CLASS_ID, &Serializer::serializeObject);
   58|  1.63k|  setSerializerMethod(data::mapping::type::__class::AbstractEnum::CLASS_ID, &Serializer::serializeEnum);
   59|       |
   60|  1.63k|  setSerializerMethod(data::mapping::type::__class::AbstractVector::CLASS_ID, &Serializer::serializeCollection);
   61|  1.63k|  setSerializerMethod(data::mapping::type::__class::AbstractList::CLASS_ID, &Serializer::serializeCollection);
   62|  1.63k|  setSerializerMethod(data::mapping::type::__class::AbstractUnorderedSet::CLASS_ID, &Serializer::serializeCollection);
   63|       |
   64|  1.63k|  setSerializerMethod(data::mapping::type::__class::AbstractPairList::CLASS_ID, &Serializer::serializeMap);
   65|  1.63k|  setSerializerMethod(data::mapping::type::__class::AbstractUnorderedMap::CLASS_ID, &Serializer::serializeMap);
   66|       |
   67|  1.63k|}
_ZN5oatpp6parser4json7mapping10Serializer19setSerializerMethodERKNS_4data7mapping4type7ClassIdEPFvPS3_PNS4_6stream22ConsistentOutputStreamERKNS6_4VoidEE:
   69|  32.7k|void Serializer::setSerializerMethod(const data::mapping::type::ClassId& classId, SerializerMethod method) {
   70|  32.7k|  const v_uint32 id = classId.id;
   71|  32.7k|  if(id >= m_methods.size()) {
  ------------------
  |  Branch (71:6): [True: 0, False: 32.7k]
  ------------------
   72|      0|    m_methods.resize(id + 1, nullptr);
   73|      0|  }
   74|  32.7k|  m_methods[id] = method;
   75|  32.7k|}