C++ Value::Begin方法代码示例

 void UNIFAQParameterLibrary::populate(rapidjson::Value &group_data, rapidjson::Value &interaction_data, rapidjson::Value &comp_data)
 {
     // Schema should have been used to validate the data already, so by this point we are can safely consume the data without checking ...
     for (rapidjson::Value::ValueIterator itr = group_data.Begin(); itr != group_data.End(); ++itr)
     {
         Group g;
         g.sgi = (*itr)["sgi"].GetInt();
         g.mgi = (*itr)["mgi"].GetInt();
         g.R_k = (*itr)["R_k"].GetDouble();
         g.Q_k = (*itr)["Q_k"].GetDouble();
         groups.push_back(g);
     }
     for (rapidjson::Value::ValueIterator itr = interaction_data.Begin(); itr != interaction_data.End(); ++itr)
     {
         InteractionParameters ip;
         ip.mgi1 = (*itr)["mgi1"].GetInt();
         ip.mgi2 = (*itr)["mgi2"].GetInt();
         ip.a_ij = (*itr)["a_ij"].GetDouble();
         ip.a_ji = (*itr)["a_ji"].GetDouble();
         ip.b_ij = (*itr)["b_ij"].GetDouble();
         ip.b_ji = (*itr)["b_ji"].GetDouble();
         ip.c_ij = (*itr)["c_ij"].GetDouble();
         ip.c_ji = (*itr)["c_ji"].GetDouble();
         interaction_parameters.push_back(ip);
     }
     for (rapidjson::Value::ValueIterator itr = comp_data.Begin(); itr != comp_data.End(); ++itr)
     {
         Component c;
         c.inchikey = (*itr)["inchikey"].GetString();
         c.registry_number = (*itr)["registry_number"].GetString();
         c.name = (*itr)["name"].GetString();
         // userid is an optional user identifier
         if ((*itr).HasMember("userid")){
             c.userid = (*itr)["userid"].GetString();
         }
         rapidjson::Value &groups = (*itr)["groups"];
         for (rapidjson::Value::ValueIterator itrg = groups.Begin(); itrg != groups.End(); ++itrg)
         {
             int count = (*itrg)["count"].GetInt();
             int sgi = (*itrg)["sgi"].GetInt();
             if  (has_group(sgi)){
                 ComponentGroup cg(count, get_group(sgi));
                 c.groups.push_back(cg);
             }
         }
         components.push_back(c);
     }
 }

bool System::Parse(rapidjson::Value& node) {
    if(node.IsArray()) {
        for(auto sound_itr = node.Begin(); sound_itr != node.End(); sound_itr ++) {
            if(sound_itr->IsObject()) {
                auto& element = (*sound_itr);

                std::shared_ptr<sound_info> sinfo = std::shared_ptr<sound_info>(new sound_info());

                if(element.HasMember("id") && element["id"].IsString()) {
                    sinfo->id = element["id"].GetString();
                }
                if(element.HasMember("src") && element["src"].IsString()) {
                    sinfo->src = element["src"].GetString();
                }
                if(element.HasMember("loop") && element["loop"].IsBool()) {
                    sinfo->loop = element["loop"].GetBool();
                }
                if(element.HasMember("volume") && element["volume"].IsNumber()) {
                    sinfo->volume = element["volume"].GetDouble();
                }
                if(element.HasMember("spatial") && element["spatial"].IsBool()) {
                    sinfo->spatial = element["spatial"].GetBool();
                }
                // store sound info
                sounds[sinfo->id] = sinfo;
            }
        }
    }

    return true;
}

int32_t fetch_event_diff::parse(const rapidjson::Value& _node_event_data)
{
    try
    {
        if (!_node_event_data.IsArray())
            return wpie_error_parse_response;

        for (auto iter = _node_event_data.Begin(), end = _node_event_data.End(); iter != end; ++iter)
        {
            std::string type;
            const auto iter_type = iter->FindMember("type");
            if (iter_type != iter->MemberEnd() && iter_type->value.IsString())
                type = rapidjson_get_string(iter_type->value);

            const auto iter_data = iter->FindMember("data");
            if (iter_data != iter->MemberEnd() && iter_data->value.IsArray())
            {
                auto cl = std::make_shared<contactlist>();
                cl->unserialize_from_diff(iter_data->value);
                diff_->insert(std::make_pair(std::move(type), std::move(cl)));
            }
        }
    }
    catch (const std::exception&)
    {
        return wpie_error_parse_response;
    }

    return 0;
}

void GeoJson::extractPoly(const rapidjson::Value& _in, Polygon& _out, const MapTile& _tile) {
    
    for (auto itr = _in.Begin(); itr != _in.End(); ++itr) {
        _out.emplace_back();
        extractLine(*itr, _out.back(), _tile);
    }
    
}

bool JSASTNode::ParseStatementArray(const rapidjson::Value &value, Vector<JSASTStatement *> &statements)
{

    assert(value.IsArray());

    for (Value::ConstValueIterator itr = value.Begin(); itr != value.End(); itr++)
    {
        JSASTStatement* stmt = ParseStatement(*itr);
        //assert(stmt);
        statements.Push(stmt);

    }

    return true;
}

bool JSASTNode::ParseExpressionArray(const rapidjson::Value &value, Vector<JSASTExpression *> &expressions)
{

    assert(value.IsArray());

    for (Value::ConstValueIterator itr = value.Begin(); itr != value.End(); itr++)
    {
        JSASTExpression* expr = ParseExpression(*itr);
        //assert(expr);
        expressions.Push(expr);

    }

    return true;
}

std::string SettingRegistry::toString(const rapidjson::Value& dflt, std::string setting_name)
{
    if (dflt.IsString())
    {
        return dflt.GetString();
    }
    else if (dflt.IsTrue())
    {
        return "true";
    }
    else if (dflt.IsFalse())
    {
        return "false";
    }
    else if (dflt.IsNumber())
    {
        std::ostringstream ss;
        ss << dflt.GetDouble();
        return ss.str();
    } 
    else if (dflt.IsArray())
    {
        std::stringstream ss;
        ss << "[";
        bool first = true;
        for (auto it = dflt.Begin(); it != dflt.End(); ++it)
        {
            if (!first)
            {
                ss << ",";
            }
            ss << toString(*it);
            first = false;
        }
        ss << "]";
        return ss.str();
    }
    else 
    {
        logError("Unrecognized data type in JSON: %s has type %s\n", setting_name.c_str(), toString(dflt.GetType()).c_str());
        return "";
    }
}

int32_t search_contacts_response::unserialize(const rapidjson::Value& array)
{
    data_.clear();
    for (auto node = array.Begin(), nend = array.End(); node != nend; ++node)
    {
        chunk c;
        { auto i = node->FindMember("sn"); if (i != node->MemberEnd() && i->value.IsString()) c.aimid_ = i->value.GetString(); }
        { auto i = node->FindMember("stamp"); if (i != node->MemberEnd() && i->value.IsString()) c.stamp_ = i->value.GetString(); }
        { auto i = node->FindMember("type"); if (i != node->MemberEnd() && i->value.IsString()) c.type_ = i->value.GetString(); }
        { auto i = node->FindMember("score"); if (i != node->MemberEnd() && i->value.IsInt()) c.score_ = i->value.GetInt(); }
        {
            auto a = node->FindMember("anketa");
            if (a != node->MemberEnd() && a->value.IsObject())
            {
                const auto& sub_node = a->value;
                { auto i = sub_node.FindMember("firstName"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.first_name_ = i->value.GetString(); }
                { auto i = sub_node.FindMember("lastName"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.last_name_ = i->value.GetString(); }
                { auto i = sub_node.FindMember("nickname"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.nick_name_ = i->value.GetString(); }
                { auto i = sub_node.FindMember("city"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.city_ = i->value.GetString(); }
                { auto i = sub_node.FindMember("state"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.state_ = i->value.GetString(); }
                { auto i = sub_node.FindMember("country"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.country_ = i->value.GetString(); }
                { auto i = sub_node.FindMember("gender"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.gender_ = i->value.GetString(); }
                {
                    auto b = sub_node.FindMember("birthDate");
                    if (b != sub_node.MemberEnd() && b->value.IsObject())
                    {
                        const auto& sub_sub_node = b->value;
                        { auto i = sub_sub_node.FindMember("year"); if (i != sub_sub_node.MemberEnd() && i->value.IsInt()) c.birthdate_.year_= i->value.GetInt(); }
                        { auto i = sub_sub_node.FindMember("month"); if (i != sub_sub_node.MemberEnd() && i->value.IsInt()) c.birthdate_.month_= i->value.GetInt(); }
                        { auto i = sub_sub_node.FindMember("day"); if (i != sub_sub_node.MemberEnd() && i->value.IsInt()) c.birthdate_.day_= i->value.GetInt(); }
                    }
                }
                { auto i = sub_node.FindMember("aboutMeCut"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.about_ = i->value.GetString(); }
            }
        }
        data_.push_back(c);
    }
    return 0;
}

double traverse_rapidjson(const rapidjson::Value &v)
{
	double x = 0;
	if (v.IsObject())
	{
		for (auto i = v.MemberBegin(); i != v.MemberEnd(); ++i)
		{
			x += traverse_rapidjson(i->value);
		}
	}
	else if (v.IsArray())
	{
		for (auto i = v.Begin(); i != v.End(); ++i)
		{
			x += traverse_rapidjson(*i);
		}
	}
	else if (v.IsNumber())
	{
		x = v.GetDouble();
	}
	return x;
}

static void parseValue(SettingValue &value, const rapidjson::Value &json_val)
{
    if (json_val.IsInt())
        value = json_val.GetInt();
    else if (json_val.IsString())
        value = std::string(json_val.GetString(), json_val.GetStringLength());
    else if (json_val.IsBool())
        value = json_val.GetBool();
    else if (json_val.IsArray())
    {
        SettingList value_list;

        for (auto it = json_val.Begin(); it != json_val.End(); ++it)
        {
            SettingValue child_val;
            parseValue(child_val, *it);
            value_list.push_back(child_val);
        }

        value = value_list;
    }
    else if (json_val.IsObject())
    {
        SettingMap value_map;

        for (auto it = json_val.MemberBegin(); it != json_val.MemberEnd(); ++it)
        {
            SettingValue child_val;
            parseValue(child_val, it->value);
            value_map[it->name.GetString()] = child_val;
        }

        value = value_map;
    }
    else
        throw std::runtime_error("Unexpected JSON value type.");
}

bool RequestMessage::parsePayload(rapidjson::Value& value, IceServalBridge* bridge)
{
  this->requests.clear();

  if (false == value.IsArray())
  {
    _log->error("Payload could not be parsed: Is not an array");
    return false;
  }

  std::string entity, entityType, scope, rep, relatedEntity;
  int count = 0;

  for (auto it = value.Begin(); it != value.End(); ++it)
  {
    if (false == it->IsArray())
    {
      _log->error("Payload could not be parsed: Id is not an array");
      return false;
    }

    count = 0;

    for (auto it2 = it->Begin(); it2 != it->End(); ++it2)
    {
      if (false == it2->IsString())
      {
        _log->error("Payload could not be parsed: Field is not a string");
        return false;
      }

      switch(count)
      {
        case 0:
          entity = it2->GetString();
          break;
        case 1:
          entityType = it2->GetString();
          break;
        case 2:
          scope = it2->GetString();
          break;
        case 3:
          rep = it2->GetString();
          break;
        case 4:
          relatedEntity = it2->GetString();
          break;
      }

      ++count;
    }

    if (count != 5)
    {
      _log->error("Payload could not be parsed: Wrong number of fields for offer");
      return false;
    }

    auto spec = std::make_shared<InformationSpecification>(entity, entityType, scope, rep, relatedEntity);
    this->requests.push_back(spec);
  }

  return true;
}

void ConvertToMsgPack(const rapidjson::Value& json, msgpack::object& object, msgpack::zone& zone)
{
	switch (json.GetType())
	{
		case rapidjson::kFalseType:
			object = false;
			break;

		case rapidjson::kTrueType:
			object = true;
			break;

		case rapidjson::kNumberType:
		{
			if (json.IsInt())
			{
				object = json.GetInt();
			}
			else if (json.IsUint())
			{
				object = json.GetUint();
			}
			else if (json.IsInt64())
			{
				object = json.GetInt64();
			}
			else if (json.IsUint64())
			{
				object = json.GetUint64();
			}
			else if (json.IsDouble())
			{
				object = json.GetDouble();
			}

			break;
		}

		case rapidjson::kStringType:
			// we allocate with 'zone', otherwise the std::string's raw pointer gets used, which won't work as it gets destructed later on
			object = msgpack::object(std::string(json.GetString(), json.GetStringLength()), zone);
			break;

		case rapidjson::kObjectType:
		{
			std::map<std::string, msgpack::object> list;

			for (auto it = json.MemberBegin(); it != json.MemberEnd(); it++)
			{
				msgpack::object newObject;
				ConvertToMsgPack(it->value, newObject, zone);

				list.insert({ it->name.GetString(), newObject });
			}

			object = msgpack::object(list, zone);

			break;
		}

		case rapidjson::kArrayType:
		{
			std::vector<msgpack::object> list;

			for (auto it = json.Begin(); it != json.End(); it++)
			{
				msgpack::object newObject;
				ConvertToMsgPack(*it, newObject, zone);

				list.push_back(newObject);
			}

			object = msgpack::object(list, zone);

			break;
		}

		default:
			object = msgpack::type::nil();
			break;
	}
}

    void json2tvalue(QVariant & output, const rapidjson::Value & input, int itype)
    {
        if(input.IsNull())
        {
            output.clear();
        }
        else if(input.IsInt64())
        {
            output = QVariant(input.GetInt64());
        }
        else if(input.IsInt())
        {
            output = QVariant(input.GetInt());
        }
        else if(input.IsDouble())
        {
            output = QVariant(input.GetDouble());
        }
        else if(input.IsBool())
        {
            output = QVariant(input.GetBool());
        }
        else if(input.IsString())
        {
            output = QVariant(QString(input.GetString()));
        }
        else if(input.IsArray())
        {
            switch(itype)
            {
            case QVariant::Point:
            {
                assert(input.Size() == 2);
                output = QPoint(input[0u].GetDouble(), input[1].GetDouble());
                break;
            }
            case QVariant::PointF:
            {
                assert(input.Size() == 2);
                output = QPointF(input[0u].GetDouble(), input[1].GetDouble());
                break;
            }
            case QVariant::Size:
            {
                assert(input.Size() == 2);
                output = QSize(input[0u].GetDouble(), input[1].GetDouble());
                break;
            }
            case QVariant::SizeF:
            {
                assert(input.Size() == 2);
                output = QSizeF(input[0u].GetDouble(), input[1].GetDouble());
                break;
            }
            case QVariant::Rect:
            {
                assert(input.Size() == 4);
                output = QRect(input[0u].GetDouble(), input[1].GetDouble(), input[2].GetDouble(), input[3].GetDouble());
                break;
            }
            case QVariant::RectF:
            {
                assert(input.Size() == 4);
                output = QRectF(input[0u].GetDouble(), input[1].GetDouble(), input[2].GetDouble(), input[3].GetDouble());
                break;
            }
            case QVariant::Vector2D:
            {
                assert(input.Size() == 2);
                output = QVector2D(input[0u].GetDouble(), input[1].GetDouble());
                break;
            }
            case QVariant::Vector3D:
            {
                assert(input.Size() == 3);
                output = QVector3D(input[0u].GetDouble(), input[1].GetDouble(), input[2].GetDouble());
                break;
            }
            case QVariant::Vector4D:
            {
                assert(input.Size() == 4);
                output = QVector4D(input[0u].GetDouble(), input[1].GetDouble(), input[2].GetDouble(), input[3].GetDouble());
                break;
            }
            case QVariant::Color:
            {
                assert(input.Size() == 4);
                output = QColor(input[0u].GetDouble(), input[1].GetDouble(), input[2].GetDouble(), input[3].GetDouble());
                break;
            }
            case QVariant::StringList:
            {
                QStringList list;
                list.reserve(input.Size());

                for(rapidjson::Value::ConstValueIterator it = input.Begin(); it != input.End(); ++it)
                {
                    QString tmp(it->GetString());
                    list.append(tmp);
                }
//.........这里部分代码省略.........