C++ json::end方法代码示例

void Pet::fromJson(nlohmann::json& val)
{
    if(val.find("id") != val.end())
    {
        setId(val.at("id"));
    }
    if(val.find("category") != val.end())
    {
        if(!val["category"].is_null())
        {
            Category newItem(Category());
            newItem.fromJson(val["category"]);
            setCategory( newItem );
        }
        
    }
    setName(val.at("name"));
    {
        m_PhotoUrls.clear();
        nlohmann::json jsonArray;
                for( auto& item : val["photoUrls"] )
        {
            m_PhotoUrls.push_back(item);
            
        }
    }
    {
        m_Tags.clear();
        nlohmann::json jsonArray;
        if(val.find("tags") != val.end())
        {
        for( auto& item : val["tags"] )
        {
            
            if(item.is_null())
            {
                m_Tags.push_back( Tag(nullptr) );
            }
            else
            {
                Tag newItem(Tag());
                newItem.fromJson(item);
                m_Tags.push_back( newItem );
            }
            
        }
        }
    }
    if(val.find("status") != val.end())
    {
        setStatus(val.at("status"));
        
    }
    
}

void deserializeChatbotActions(const nlohmann::json& chatbot,
                               ChatbotActionModel& chatbotActionModel) {
  nlohmann::json::const_iterator it;

  it = chatbot.find("replies");
  if (it != chatbot.end() && (*it).is_object()) {
    deserializeReplies(*it, chatbotActionModel);
  }

  it = chatbot.find("replies_by_state_action");
  if (it != chatbot.end() && (*it).is_object()) {
    deserializeReplyIdsByStateAndActionId(*it, chatbotActionModel);
  }
}

void deserializeDictionaryModel(const nlohmann::json& input,
                                DictionaryModel& dictionaryModel) {
  nlohmann::json::const_iterator it = input.find("entities");
  if (it != input.end() && (*it).is_object()) {
    deserializeDictionary(*it, dictionaryModel);
  }
}

void ExprFunction<T>::set(const nlohmann::json &j, const Tvarvec &vars) {
    Tconstvec consts;
    auto it = j.find("constants");
    if (it != j.end())
        for (auto i = it->begin(); i != it->end(); ++i)
            consts.push_back({i.key(), i.value()});
    set(j.at("function"), vars, consts);
}

/*
 * The check_equal function determines if the labels of the datanode and the querynode are equal.
 * The function iterates through all the labels of the query node and compares its value to that of the datanode.
 * It returns true only if all the labels match; returns false otherwises.
 */
    bool check_equal(nlohmann::json datanode, nlohmann::json querynode) {
        for (nlohmann::json::iterator it = querynode.begin(); it != querynode.end(); ++it) {
            if ((it.key() != "id") && (it.key() != "out_degree")) {
                if (datanode.find(it.key()) != datanode.end()) {
                    if(datanode[it.key()].is_string())
                    {
                        std::string d = datanode[it.key()], q= it.value();
                        if(d.find(q)== std::string::npos)
                            return false;
                    }
                    else if (datanode[it.key()] != it.value())
                        return false;
                } else
                    return false;
            }
        }
        return true;
    }

void deserializeChatbotActionModel(const nlohmann::json& input,
                                   ChatbotActionModel& chatbotActionModel) {
  nlohmann::json::const_iterator it;

  it = input.find("chatbot");
  if (it != input.end() && (*it).is_object()) {
    deserializeChatbotActions(*it, chatbotActionModel);
  }
}

void deserializeIntentStoryModel(const nlohmann::json& input,
                                 IntentStoryModel& intentStoryModel) {
  nlohmann::json::const_iterator it;

  it = input.find("intent_story");
  if (it != input.end() && (*it).is_object()) {
    deserializeIntentStory(*it, intentStoryModel);
  }
}

void deserializeIntentModel(const nlohmann::json& input,
                            const DictionaryModel& dictionaryModel,
                            IntentModel& intentModel) {
  nlohmann::json::const_iterator it = input.find("intents");
  if (it != input.end() && (*it).is_array()) {
    const nlohmann::json::array_t& intents = *it;
    deserializeIntents(intents, dictionaryModel, intentModel);
  }
}

bool BrokerMessage::isValid(const nlohmann::json& jsonObj) const
{
    auto it = jsonObj.find("command");
    if (it == jsonObj.end() ||
        !it->is_string()) {
        return false;
    }

    std::unordered_set<std::string> properties;

    if (*it == "publish") {
        properties = { "topics", "payload" };
    }
    else if (*it == "subscribe") {
        properties = { "topics" };
    }
    else if (*it == "unsubscribe") {
        properties = { "topics" };
    }
    else {
        return false;
    }

    if (properties.find("topics") != properties.end()) {
        it = jsonObj.find("topics");

        if (it == jsonObj.end() ||
            !it->is_array()) {
            return false;
        }
    }

    if (properties.find("payload") != properties.end()) {
        it = jsonObj.find("payload");

        if (it == jsonObj.end() ||
            !it->is_string()) {
            return false;
        }
    }

    return true;
}

void deserializeIntentStory(const nlohmann::json& story,
                            IntentStoryModel& intentStoryModel) {
  nlohmann::json::const_iterator it;

  it = story.find("root");
  if (it != story.end() && (*it).is_string()) {
    IntentStoryModel::VertexInfo vInfo;
    vInfo.stateId = *it;
    IntentStoryModel::StoryGraph::Vertex v =
        intentStoryModel.graph.addVertex(vInfo);
    intentStoryModel.vertexByStateId[vInfo.stateId] = v;
    intentStoryModel.rootStateId = vInfo.stateId;
  }

  it = story.find("graph");
  if (it != story.end() && (*it).is_object()) {
    deserializeGraph(*it, intentStoryModel);
  }
}

 /**
  * Import parameters from given json object.
  * Throw std::runtime_error if given json is malformated.
  */
 inline void loadJSON(const nlohmann::json& j)
 {
     //Empty case
     if (j.is_null()) {
         return;
     }
     //Check json type
     if (!j.is_object()) {
         throw std::runtime_error(
             "ParametersContainer load parameters json not object");
     }
     //Iterate on json entries
     for (nlohmann::json::const_iterator it=j.begin();it!=j.end();it++) {
         if (it.value().is_boolean()) {
             //Boolean
             if (_paramsBool.count(it.key()) == 0) {
                 throw std::runtime_error(
                     "ParametersContainer load parameters json bool does not exist: " 
                     + it.key());
             } else {
                 paramBool(it.key()).value = it.value();
             }
         } else if (it.value().is_number()) {
             //Number
             if (_paramsNumber.count(it.key()) == 0) {
                 throw std::runtime_error(
                     "ParametersContainer load parameters json number does not exist: " 
                     + it.key());
             } else {
                 paramNumber(it.key()).value = it.value();
             }
         } else if (it.value().is_string()) {
             //String
             if (_paramsStr.count(it.key()) == 0) {
                 throw std::runtime_error(
                     "ParametersContainer load parameters json str does not exist: " 
                     + it.key());
             } else {
                 paramStr(it.key()).value = it.value();
             }
         } else {
             throw std::runtime_error(
                 "ParametersContainer load parameters json malformated");
         }
     }
 }

void User::fromJson(nlohmann::json& val)
{
    if(val.find("id") != val.end())
    {
        setId(val.at("id"));
    }
    if(val.find("username") != val.end())
    {
        setUsername(val.at("username"));
        
    }
    if(val.find("firstName") != val.end())
    {
        setFirstName(val.at("firstName"));
        
    }
    if(val.find("lastName") != val.end())
    {
        setLastName(val.at("lastName"));
        
    }
    if(val.find("email") != val.end())
    {
        setEmail(val.at("email"));
        
    }
    if(val.find("password") != val.end())
    {
        setPassword(val.at("password"));
        
    }
    if(val.find("phone") != val.end())
    {
        setPhone(val.at("phone"));
        
    }
    if(val.find("userStatus") != val.end())
    {
        setUserStatus(val.at("userStatus"));
    }
    
}

bool Contains(const nlohmann::json& json, const std::string& member)
{
    return json.is_object() && json.find(member) != json.end();
}

void Difference::PrepareGrade(const nlohmann::json& j) {
  std::cout << "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%" << std::endl;
  std::cout << "PREPARE GRADE" << std::endl;


  // --------------------------------------------------------
  //std::cout << "json " << j.dump(4) << std::endl;
  if (j.find("max_char_changes") != j.end()) {
    std::cout << "MAX CHAR CHANGES" << std::endl;

    int max_char_changes = j.value("max_char_changes", -1);
    assert (max_char_changes > 0);
    int min_char_changes = j.value("min_char_changes",0);
    assert (min_char_changes >= 0);
    assert (min_char_changes < max_char_changes);

    assert (total_char > 0);
    if (max_char_changes > total_char) {
      std::cout << "WARNING!  max_char_changes > total_char)" << std::endl;
      max_char_changes = total_char;
      if (min_char_changes > max_char_changes) {
        min_char_changes = max_char_changes-1;
      }
      assert (min_char_changes >= 0);
    }
    assert (max_char_changes <= total_char);

    int char_changes = char_added + char_deleted;

    std::cout << "char_changes=" << char_changes << " min=" << min_char_changes << " max=" << max_char_changes << std::endl;

    int min_max_diff = max_char_changes-min_char_changes;
    int lower_bar = std::max(0,min_char_changes-min_max_diff);
    int upper_bar = max_char_changes + min_max_diff;

    assert (0 <= lower_bar &&
      lower_bar <= min_char_changes &&
      min_char_changes <= max_char_changes &&
      max_char_changes <= upper_bar);

    float grade;
    if (char_changes < lower_bar) {
      std::cout << "too few char changes (zero credit)" << std::endl;
      messages.push_back(std::make_pair(MESSAGE_FAILURE,"ERROR!  Approx " + std::to_string(char_changes) + " characters added and/or deleted.  Significantly fewer character changes than allowed."));
    } else if (char_changes < min_char_changes) {
      std::cout << "less than min char changes (partial credit)" << std::endl;
      float numer = min_char_changes - char_changes;
      float denom = min_max_diff;
      std::cout << "numer " << numer << " denom= " << denom << std::endl;
      assert (denom > 0);
      grade = 1 - numer/denom;
      messages.push_back(std::make_pair(MESSAGE_FAILURE,"ERROR!  Approx " + std::to_string(char_changes) + " characters added and/or deleted.  Fewer character changes than allowed."));
    } else if (char_changes < max_char_changes) {
      messages.push_back(std::make_pair(MESSAGE_SUCCESS,"Approx " + std::to_string(char_changes) + " characters added and/or deleted.  Character changes within allowed range."));
      std::cout << "between min and max char changes (full credit)" << std::endl;
      grade = 1.0;
    } else if (char_changes < upper_bar) {
      std::cout << "more than max char changes (partial credit)" << std::endl;
      float numer = char_changes - max_char_changes;
      float denom = min_max_diff;
      assert (denom > 0);
      grade = 1 - numer/denom;
      std::cout << "numer " << numer << " denom= " << denom << std::endl;
      messages.push_back(std::make_pair(MESSAGE_FAILURE,"ERROR!  Approx " + std::to_string(char_changes) + " characters added and/or deleted.  More character changes than allowed."));
    } else {
      std::cout << "too many char changes (zero credit)" << std::endl;
      messages.push_back(std::make_pair(MESSAGE_FAILURE,"ERROR!  Approx " + std::to_string(char_changes) + " characters added and/or deleted.  Significantly more character changes than allowed."));
      grade = 0.0;
    }
    std::cout << "grade " << grade << std::endl;
    assert (grade >= -0.00001 & grade <= 1.00001);
    this->setGrade(grade);
  }

  // --------------------------------------------------------
  else if (this->extraStudentOutputOk) {
    // only missing lines (deletions) are a problem
    int count_of_missing_lines = 0;
    for (int x = 0; x < this->changes.size(); x++) {
      int num_b_lines = this->changes[x].b_changes.size();
      if (num_b_lines > 0) {
        count_of_missing_lines += num_b_lines;
      }
    }
    int output_length = this->output_length_b;
    std::cout << "COMPARE outputlength=" << output_length << " missinglines=" << count_of_missing_lines << std::endl;
    assert (count_of_missing_lines <= output_length);
    float grade = 1.0;
    if (output_length > 0) {
      //std::cout << "SES [ESOO] calculating grade " << this->distance << "/" << output_length << std::endl;
      //grade -= (this->distance / (float) output_length );
      grade -= count_of_missing_lines / float(output_length);
      std::cout <<
        "grade:  missing_lines [ " << count_of_missing_lines <<
        "] / output_length " << output_length << "]\n";
      //std::cout << "SES [ESOO] calculated grade = " << std::setprecision(1) << std::fixed << std::setw(5) << grade << " " << std::setw(5) << (int)floor(5*grade) << std::endl;
      if (grade < 1.0 && this->only_whitespace_changes) {
        std::cout << "ONLY WHITESPACE DIFFERENCES! adjusting grade: " << grade << " -> ";
        // FIXME:  Ugly, but with rounding, this will be only a -1 point grade for this test case
        grade = std::max(grade,0.99f);
//.........这里部分代码省略.........

    nlohmann::json collection::query(nlohmann::json::object_t const& selector, nlohmann::json::object_t const& modifier, int flags) throw(ejdb_exception)
    {
        nlohmann::json q1 = selector;
        nlohmann::json q2 = modifier;

        bool with_modifier = !q2.empty();
        if(with_modifier) {
            std::swap(q1, q2);
        }

        auto* ejdb_query = ejdbcreatequery(_db.get(), convert_to_bson(q1).get(), with_modifier ? convert_to_bson(q2).get() : nullptr, (int)with_modifier, nullptr);
        if(!ejdb_query) {
            throw_last_ejdb_exception();
        }

        uint32_t count;
        std::shared_ptr<TCXSTR> log(tcxstrnew(), tcxstrdel);
        auto cursor = ejdbqryexecute(_coll.get(), ejdb_query, &count, flags, log.get());
        ejdbquerydel(ejdb_query);

        nlohmann::json updates;
        nlohmann::json upserts;
        nlohmann::json dropall;
        nlohmann::json const json_log = evaluate_log(std::string(log->ptr, log->size));
        if(json_log.find("updating_mode") != json_log.end() && json_log["updating_mode"]) {
            if(json_log.find("$update") != json_log.end()) {
                updates = json_log["$update"];
                if(updates.type() != nlohmann::json::value_t::array) {
                    updates = nlohmann::json::array_t({ updates });
                }
            }
            if(json_log.find("$upsert") != json_log.end()) {
                upserts = json_log["$upsert"];
                if(upserts.type() != nlohmann::json::value_t::array) {
                    upserts = nlohmann::json::array_t({ upserts });
                }
                for(nlohmann::json::object_t doc: upserts) {
                    std::string const id = doc["_id"];
                    doc.erase("_id");
                    document_added(id, doc);
                }
            }
            if(json_log.find("$dropall") != json_log.end()) {
                for(std::string const& id: json_log["$dropall"]) {
                    dropall.push_back(id);
                }
            }
        }

        nlohmann::json return_val;
        if(flags & JBQRYCOUNT) {
            return_val = count;
        } else {
            std::vector<nlohmann::json::object_t> results;
            results.reserve(count);
            for(int i = 0; i < count; ++i) {
                int data_size = 0;
                auto const& result = convert_to_json(std::shared_ptr<bson>(bson_create_from_buffer(static_cast<char const*>(ejdbqresultbsondata(cursor, i, &data_size)), data_size), bson_destroy));
                if(i < updates.size()) {
                    auto const& update = updates[i];
                    if(result != update) {
                        auto const diff = modified_fields(result, update);
                        document_pre_changed(result["_id"], result, update);
                        document_changed(result["_id"], diff["fields"], diff["cleared"]);
                    }
                }
                if(i < dropall.size()) {
                    std::string const& id = dropall[i];
                    if(result["_id"] == id) {
                        document_pre_removed(id, result);
                        document_removed(id);
                    }

                }
                results.push_back(result);
            }
            ejdbqresultdispose(cursor);
            return_val = results;
        }

        if(flags & JBQRYFINDONE) {
            return_val = return_val.empty() ? nlohmann::json::object() : return_val[0];
        }

        return return_val;
    }