예제 #1
0
inline bool fromJson(const rapidjson::Value &v, const char *field, T &dst)
{
    const rapidjson::Value::Member *member = v.FindMember(field);
    if (!member)
        return false;

    return fromJson(member->value, dst);
}
예제 #2
0
name_t::name_t(const rapidjson::Value &json_value) {

    auto last_iter = json_value.FindMember("last");
    if ( last_iter != json_value.MemberEnd() ) {

        assert(last_iter->value.IsString());
        last = last_iter->value.GetString();
    }

    auto first_iter = json_value.FindMember("first");
    if ( first_iter != json_value.MemberEnd() ) {

        assert(first_iter->value.IsString());
        first = first_iter->value.GetString();
    }

}
예제 #3
0
bool JSASTLabeledStatement::Parse(const rapidjson::Value& value)
{
    JSASTStatement::Parse(value);

    const Value::Member* body = value.FindMember("body");
    assert(body);

    const Value::Member* label = value.FindMember("label");
    assert(label);


    body_ = ParseStatement(body->value);
    label_ = (JSASTIdentifier*) ParseExpression(label->value,  JSAST_IDENTIFIER);

    return body_ && label_;

}
예제 #4
0
bool JSASTIdentifier::Parse(const rapidjson::Value& value)
{
    JSASTExpression::Parse(value);

    if (value.FindMember("name"))
        name_ = value["name"].GetString();
    return true;
}
예제 #5
0
void ensure_has_object_mem(rapidjson::Value & _val, rapidjson::Value::StringRefType _name, rapidjson::Document & _doc)
{
	if (!_val.HasMember(_name)) {
		rapidjson::Value v(rapidjson::kObjectType);
		_val.AddMember(_name, v, _doc.GetAllocator());
	}
	RAPIDJSON_ASSERT(_val.FindMember(_name)->value.IsObject());
}
예제 #6
0
int32_t fetch_event_imstate::parse(const rapidjson::Value& _node_event_data)
{
    auto iter_imstates = _node_event_data.FindMember("imStates");
    if  (iter_imstates == _node_event_data.MemberEnd() || !iter_imstates->value.IsArray())
        return wpie_error_parse_response;

    for (auto iter_state = iter_imstates->value.Begin(); iter_state != iter_imstates->value.End(); ++iter_state)
    {
        imstate ustate;

        auto iter_request_id = iter_state->FindMember("sendReqId");
        if (iter_request_id == iter_state->MemberEnd() || !iter_request_id->value.IsString())
            continue;

        ustate.set_request_id(rapidjson_get_string(iter_request_id->value));

        auto iter_msg_id = iter_state->FindMember("msgId");
        if (iter_msg_id == iter_state->MemberEnd() || !iter_msg_id->value.IsString())
            continue;

        ustate.set_msg_id(rapidjson_get_string(iter_msg_id->value));

        auto iter_state_state = iter_state->FindMember("state");
        if (iter_state_state == iter_state->MemberEnd() || !iter_state_state->value.IsString())
            continue;

        const std::string state = rapidjson_get_string(iter_state_state->value);

        if (state == "failed")
            ustate.set_state(imstate_sent_state::failed);
        else if (state == "sent")
            ustate.set_state(imstate_sent_state::sent);
        else if (state == "delivered")
            ustate.set_state(imstate_sent_state::delivered);

        auto iter_hist_msg_id = iter_state->FindMember("histMsgId");
        if (iter_hist_msg_id != iter_state->MemberEnd() && iter_hist_msg_id->value.IsInt64())
        {
            ustate.set_hist_msg_id(iter_hist_msg_id->value.GetInt64());
        }

        auto iter_before_hist_msg_id = iter_state->FindMember("beforeHistMsgId");
        if (iter_before_hist_msg_id != iter_state->MemberEnd() && iter_before_hist_msg_id->value.IsInt64())
        {
            ustate.set_before_hist_msg_id(iter_before_hist_msg_id->value.GetInt64());
        }

        auto iter_error_code = iter_state->FindMember("errorCode");
        if (iter_error_code != iter_state->MemberEnd() && iter_error_code->value.IsInt())
        {
            ustate.set_error_code(iter_error_code->value.GetInt());
        }

        states_.push_back(ustate);
    }

    return 0;
}
예제 #7
0
bool JSASTComment::Parse(const rapidjson::Value& value)
{
    JSASTNode::Parse(value);

    // Block or Line
    if (value.FindMember("type"))
    {
        String type = value["type"].GetString();
        isBlock_ = type == "Block";
    }

    if (value.FindMember("value"))
    {
        value_ = value["value"].GetString();
    }

    return true;
}
예제 #8
0
파일: box.hpp 프로젝트: nasailja/pamhd
	/*!
	Sets box geometry from given rapidjson object.

	Given object must have "start" and "end" items
	and both must be arrays of 3 numbers.
	*/
	void set_geometry(const rapidjson::Value& object)
	{
		const auto& obj_start_i = object.FindMember("start");
		if (obj_start_i == object.MemberEnd()) {
			throw std::invalid_argument(__FILE__ ": Given object doesn't have a start item.");
		}
		const auto& obj_start = obj_start_i->value;

		if (not obj_start.IsArray()) {
			throw std::invalid_argument(__FILE__ ": Start item isn't an array.");
		}

		if (obj_start.Size() != 3) {
			throw std::invalid_argument(__FILE__ ": Start item doesn't have a length of 3.");
		}

		this->start_rw[0] = obj_start[0].GetDouble();
		this->start_rw[1] = obj_start[1].GetDouble();
		this->start_rw[2] = obj_start[2].GetDouble();

		const auto& obj_end_i = object.FindMember("end");
		if (obj_end_i == object.MemberEnd()) {
			throw std::invalid_argument(__FILE__ ": Given object doesn't have an end item.");
		}
		const auto& obj_end = obj_end_i->value;

		if (not obj_end.IsArray()) {
			throw std::invalid_argument(__FILE__ ": End item isn't an array.");
		}

		if (obj_end.Size() != 3) {
			throw std::invalid_argument(__FILE__ ": End item doesn't have a length of 3.");
		}

		this->end_rw[0] = obj_end[0].GetDouble();
		this->end_rw[1] = obj_end[1].GetDouble();
		this->end_rw[2] = obj_end[2].GetDouble();

		for (size_t i = 0; i < 3; i++) {
			if (this->end_rw[i] <= this->start_rw[i]) {
				throw std::invalid_argument(__FILE__ ": Given object ends before it starts.");
			}
		}
	}
예제 #9
0
static void convert_struct_by_name(rapidjson::Document & /*doc*/,
			   const rapidjson::Value & val,
			   const std::string & tname,
			   const std::size_t lvl)
{
	const char * ename = tname.c_str();
	//bool is_msg = is_as_msg(val);
	//const char * fn_prefix = is_msg ? "" : "static inline ";
	const rapidjson::Value & fields = val.FindMember("fields")->value;

	filebuf & outf = s_outf_converter;
	if (fields.MemberCount() > 0) {
		outf.pf(lvl, "/// @%s\n", ename);
		outf.pf(lvl, "static inline rapidjson::Value c2json(rapidjson::Document & jd, const %s & src)\n", ename);
		outf.pf(lvl, "{\n");

		outf.pf(lvl+1, "rapidjson::Value v(rapidjson::kObjectType);\n");
		for (rapidjson::Value::ConstMemberIterator itr = fields.MemberBegin(); itr != fields.MemberEnd(); ++itr) {
			const char * mname = itr->name.GetString();
			auto & mval = itr->value;
			if (mval.FindMember("maybenull")->value.GetBool()) {
				outf.pf(lvl+1, "ENC_MEM_IF(jd, \"%s\", v, src.%s, src.has_%s);\n", mname, mname, mname);
			}
			else {
				outf.pf(lvl+1, "ENC_MEM(jd, \"%s\", v, src.%s);\n", mname, mname);
			}
		}
		outf.pf(0, "\n");
		outf.pf(lvl+1, "return v;\n");

		outf.pf(lvl, "}\n");

		outf.pf(lvl, "static inline void json2c(%s & dst, const rapidjson::Value & src)\n", ename);
		outf.pf(lvl, "{\n");
		for (rapidjson::Value::ConstMemberIterator itr = fields.MemberBegin(); itr != fields.MemberEnd(); ++itr) {
			const char * mname = itr->name.GetString();
			auto & mval = itr->value;
			if (mval.FindMember("maybenull")->value.GetBool()) {
				outf.pf(lvl+1, "DEC_MEM_IF(\"%s\", src, dst.%s, dst.has_%s);\n", mname, mname, mname);
			}
			else {
				outf.pf(lvl+1, "DEC_MEM(\"%s\", src, dst.%s);\n", mname, mname);
			}
		}
		outf.pf(lvl, "}\n");

		outf.pf(0, "\n");
	}
	else {
		outf.pf(lvl, "static inline rapidjson::Value c2json(rapidjson::Document & /*jd*/, const %s & /*src*/) {\n", ename);
		outf.pf(lvl+1, "return rapidjson::Value(rapidjson::kObjectType);\n");
		outf.pf(lvl, "}\n");
		outf.pf(lvl, "static inline void json2c(%s & /*dst*/, const rapidjson::Value & /*src*/) {}\n", ename);
		outf.pf(0, "\n");
	}
}
예제 #10
0
QueryError OnCommand(const rapidjson::Value &p_Args, std::string *p_Result)
{
    // Get the "command" argument
    auto s_CommandValue = p_Args.FindMember("command");
    if (s_CommandValue == p_Args.MemberEnd() || !s_CommandValue->value.IsString())
    {
        *p_Result = "Bad query: A \"command\" argument is required and must be a string";
        return QueryError_BadQuery;
    }

    // Get the "internal" argument (defaults to false)
    auto s_InternalValue = p_Args.FindMember("internal");
    auto s_IsInternal = (s_InternalValue != p_Args.MemberEnd() && s_InternalValue->value.IsBool() && s_InternalValue->value.GetBool());

    // Run the command
    if (!Modules::CommandMap::Instance().ExecuteCommandWithStatus(s_CommandValue->value.GetString(), !s_IsInternal, p_Result))
        return QueryError_CommandFailed;
    return QueryError_Ok;
}
예제 #11
0
int32_t robusto_add_client::parse_results(const rapidjson::Value& _node_results)
{
    auto iter_client_id = _node_results.FindMember("clientId");
    if (iter_client_id == _node_results.MemberEnd())
        return wpie_http_parse_response;

    client_id_ = iter_client_id->value.GetUint();

    return 0;
}
예제 #12
0
bool JSASTBlockStatement::Parse(const rapidjson::Value& value)
{
    if (value.FindMember("body"))
    {
        ParseStatementArray(value["body"], body_);

    }

    return true;

}
예제 #13
0
int32_t favorite::unserialize(const rapidjson::Value& _node)
{
    auto iter_aimid = _node.FindMember("aimId");

    if (iter_aimid == _node.MemberEnd() || !iter_aimid->value.IsString())
        return -1;

    aimid_ = iter_aimid->value.GetString();

    auto iter_time = _node.FindMember("time");
    if (iter_time == _node.MemberEnd() || !iter_time->value.IsInt64())
    {
        time_ = 0;
        return 0;
    }

    time_ = iter_time->value.GetInt64();

    return 0;
}
예제 #14
0
	inline auto GetIterator(const rapidjson::Value& value, const char* name)
	{
		auto it = value.FindMember(name);

		if (it == value.MemberEnd())
		{
			SDR::Error::Make("Member Json value \"%s\" not found", name);
		}

		return it;
	}
예제 #15
0
MapPoint deserializePoint(rapidjson::Value& value)
{
    MapPoint p;
    rapidjson::Value& position = value.FindMember("position")->value;
    if(position.IsArray())
    {
        p.point.x = position[0].GetDouble();
        p.point.y = position[1].GetDouble();
    }
    rapidjson::Value& name = value.FindMember("name")->value;
    if(name.IsString())
    {
        p.name = name.GetString();
    }
    rapidjson::Value& desc = value.FindMember("description")->value;
    if(desc.IsString())
    {
        p.description = desc.GetString();
    }
    return p;
}
예제 #16
0
bool JSASTNode::ParseLoc(const rapidjson::Value& value)
{
    // SpiderMonkey can have this for loc :/
    if (value.IsNull())
        return true;

    assert(value.IsObject());

    const Value::Member* mstart = value.FindMember("start");
    assert(mstart);

    const Value::Member* mend = value.FindMember("end");
    assert(mend);

    loc_.startLine_ = mstart->value["line"].GetInt();
    loc_.startColumn_ = mstart->value["column"].GetInt();
    loc_.endLine_ = mend->value["line"].GetInt();
    loc_.endColumn_ = mend->value["column"].GetInt();

    return true;
}
예제 #17
0
bool JSASTExpressionStatement::Parse(const rapidjson::Value& value)
{
    JSASTStatement::Parse(value);

    const Value::Member* expr = value.FindMember("expression");
    assert(expr);

    expression_ = ParseExpression(expr->value);

    return expression_ != NULL;

}
예제 #18
0
 void etcd_packer::unpack_int(rapidjson::Value &json_val, const char *key, uint64_t &out) {
     rapidjson::Value::MemberIterator iter = json_val.FindMember(key);
     if (iter == json_val.MemberEnd()) {
         out = 0;
     } else {
         if (iter->value.IsUint64()) {
             out = iter->value.GetUint64();
         } else if (iter->value.IsString()) {
             const char *val = iter->value.GetString();
             ::util::string::str2int(out, val);
         }
     }
 }
예제 #19
0
        bool etcd_packer::unpack_string(rapidjson::Value &json_val, const char *key, std::string &val) {
            rapidjson::Value::MemberIterator iter = json_val.FindMember(key);
            if (iter == json_val.MemberEnd()) {
                return false;
            }

            switch (iter->value.GetType()) {
            case rapidjson::kNullType: {
                val.clear();
                break;
            }
            case rapidjson::kFalseType: {
                val = "false";
                break;
            }
            case rapidjson::kTrueType: {
                val = "true";
                break;
            }
            case rapidjson::kObjectType: {
                val = "[object object]";
                break;
            }
            case rapidjson::kArrayType: {
                val = "[object array]";
                break;
            }
            case rapidjson::kStringType: {
                val = iter->value.GetString();
                break;
            }
            case rapidjson::kNumberType: {
                std::stringstream ss;
                if (iter->value.IsDouble()) {
                    ss << iter->value.GetDouble();
                } else if (iter->value.IsInt()) {
                    ss << iter->value.GetInt();
                } else if (iter->value.IsUint()) {
                    ss << iter->value.GetUint();
                } else if (iter->value.IsInt64()) {
                    ss << iter->value.GetInt64();
                } else {
                    ss << iter->value.GetUint64();
                }
                val = ss.str();
                break;
            }
            }

            return true;
        }
예제 #20
0
int32_t my_info::unserialize(const rapidjson::Value& _node)
{
    auto iter_aimid = _node.FindMember("aimId");
    if (iter_aimid != _node.MemberEnd() && iter_aimid->value.IsString())
        aimId_ = iter_aimid->value.GetString();

    auto iter_displayId = _node.FindMember("displayId");
    if (iter_displayId != _node.MemberEnd() && iter_displayId->value.IsString())
        displayId_ = iter_displayId->value.GetString();

    auto iter_friendlyName = _node.FindMember("friendly");
    if (iter_friendlyName != _node.MemberEnd() && iter_friendlyName->value.IsString())
        friendlyName_ = iter_friendlyName->value.GetString();

    auto iter_state = _node.FindMember("state");
    if (iter_state != _node.MemberEnd() && iter_state->value.IsString())
        state_ = iter_state->value.GetString();

    auto iter_userType = _node.FindMember("userType");
    if (iter_userType != _node.MemberEnd() && iter_userType->value.IsString())
        userType_ = iter_userType->value.GetString();

    auto iter_phoneNumber = _node.FindMember("attachedPhoneNumber");
    if (iter_phoneNumber != _node.MemberEnd() && iter_phoneNumber->value.IsString())
        phoneNumber_ = iter_phoneNumber->value.GetString();

    auto iter_flags = _node.FindMember("globalFlags");
    if (iter_flags != _node.MemberEnd() && iter_flags->value.IsUint())
        flags_ = iter_flags->value.GetUint();

    auto iter_expressions = _node.FindMember("expressions");
    if (iter_expressions != _node.MemberEnd())
    {
        const auto & expression_node = iter_expressions->value;
        auto iter_large_icon = expression_node.FindMember("largeBuddyIcon");
        if (iter_large_icon != expression_node.MemberEnd() && iter_large_icon->value.IsString())
            largeIconId_ = iter_large_icon->value.GetString();
    }

    if (state_ == "occupied" || state_ == "na" || state_ == "busy")
        state_ = "dnd";
    else if (state_ == "away")
        state_ = "away";
    else if (state_ != "offline" && state_ != "invisible")
        state_ = "online";

    return 0;
}
예제 #21
0
QueryError OnSendChat(const rapidjson::Value &p_Args, std::string *p_Result)
{
    auto message = p_Args.FindMember("message");
    auto teamChat = p_Args.FindMember("teamChat");

    if (message == p_Args.MemberEnd() || !message->value.IsString())
    {
        *p_Result = "Bad query: A \"message\" argument is required and must be a string";
        return QueryError_BadQuery;
    }
    if (teamChat == p_Args.MemberEnd() || !teamChat->value.IsBool())
    {
        *p_Result = "Bad query: A \"teamChat\" argument is required and must be a boolean";
        return QueryError_BadQuery;
    }

    if(teamChat->value.GetBool())
        *p_Result = Server::Chat::SendTeamMessage(message->value.GetString());
    else
        *p_Result = Server::Chat::SendGlobalMessage(message->value.GetString());

    return QueryError_Ok;
}
예제 #22
0
void ArchiveMetadata::loadJson(const rapidjson::Value& metadataDoc) {
    rapidjson::Value::ConstMemberIterator itr = metadataDoc.FindMember("archive_name");
    if (itr != metadataDoc.MemberEnd())
        archiveName.assign(itr->value.GetString());

    archiveFormatName.assign(metadataDoc["archive_format_name"].GetString());
    archiveFormat = metadataDoc["archive_format"].GetUint64();

    focusedEntry = metadataDoc["focused_entry"].GetString();
  
    for (const auto &entryVal : metadataDoc["archive_structure"].GetArray()) {
        entryMetadata.push_back(ArchiveEntryMetadata::fromJson(entryVal));
    }
}
예제 #23
0
static inline void read_groups_array(std::vector<int> *result, const char *name, const rapidjson::Value &value) {
    if (const auto *m = value.FindMember(name)) {
        if (m->value.IsArray()) {
            std::transform(m->value.Begin(), m->value.End(),
                           std::back_inserter(*result),
                           std::bind(&rapidjson::Value::GetInt, std::placeholders::_1)
                          );
        } else {
            std::ostringstream str;
            str << name << "value must be of array type";
            throw configuration_error(str.str().c_str());
        }
    }
}
예제 #24
0
QueryError OnCaptureInput(const rapidjson::Value &p_Args, std::string *p_Result)
{
    // Get the "capture" argument
    auto s_CaptureValue = p_Args.FindMember("capture");
    if (s_CaptureValue == p_Args.MemberEnd() || !s_CaptureValue->value.IsBool())
    {
        *p_Result = "Bad query: A \"capture\" argument is required and must be a boolean";
        return QueryError_BadQuery;
    }

    // Toggle input capture
    Web::Ui::ScreenLayer::CaptureInput(s_CaptureValue->value.GetBool());
    return QueryError_Ok;
}
예제 #25
0
std::string get_value_as_string(const rapidjson::Value& object, const char* key) {
    assert(object.IsObject());

    const auto it = object.FindMember(key);
    if (it == object.MemberEnd()) {
        return "";
    }

    if (it->value.IsString()) {
        return it->value.GetString();
    }

    throw config_error{std::string{"Value for name '"} + key + "' must be a string."};
}
예제 #26
0
bool JSASTVariableDeclarator::Parse(const rapidjson::Value& value)
{
    JSASTExpression::Parse(value);

    id_ = ParseExpression(value["id"]);

    const Value::Member* init = value.FindMember("init");
    if (init && init->value.IsObject())
    {
        init_ = ParseExpression(init->value);
    }

    return true;

}
예제 #27
0
        bool etcd_packer::unpack_base64(rapidjson::Value &json_val, const char *key, std::string &val) {
            rapidjson::Value::MemberIterator iter = json_val.FindMember(key);
            if (iter == json_val.MemberEnd()) {
                return false;
            }

            if (!iter->value.IsString()) {
                return false;
            }

            const char *base64_val    = iter->value.GetString();
            size_t      base64_val_sz = strlen(base64_val);

            return 0 == util::base64_decode(val, reinterpret_cast<const unsigned char *>(base64_val), base64_val_sz);
        }
예제 #28
0
    BlockDescriptor(const std::string &name, const rapidjson::Value &v, ModelResolver &resolver)
    : _name(name)
    {
        const rapidjson::Value::Member *variants = v.FindMember("variants");

        if (variants && variants->value.IsObject()) {
            const rapidjson::Value::Member *begin = variants->value.MemberBegin();
            const rapidjson::Value::Member *end   = variants->value.MemberEnd();

            for (auto i = begin; i < end; ++i) {
                if (i->value.IsObject() || i->value.IsArray())
                    _variants.emplace_back(i->name.GetString(), i->value, resolver);
            }
        }
    }
예제 #29
0
void GeoJson::extractLayer(const rapidjson::Value& _in, Layer& _out, const MapTile& _tile) {
    
    const auto& featureIter = _in.FindMember("features");
    
    if (featureIter == _in.MemberEnd()) {
        logMsg("ERROR: GeoJSON missing 'features' member\n");
        return;
    }
    
    const auto& features = featureIter->value;
    for (auto featureJson = features.Begin(); featureJson != features.End(); ++featureJson) {
        _out.features.emplace_back();
        extractFeature(*featureJson, _out.features.back(), _tile);
    }
    
}
예제 #30
0
bool search_contacts_response::unserialize_contacts(const rapidjson::Value& _node)
{
    auto contacts_node = _node.FindMember("data");
    if (contacts_node != _node.MemberEnd())
    {
        if (!contacts_node->value.IsArray())
            return false;

        contacts_data_.clear();
        for (auto node = contacts_node->value.Begin(), nend = contacts_node->value.End(); node != nend; ++node)
        {
            contact_chunk c;
            { auto i = node->FindMember("sn"); if (i != node->MemberEnd() && i->value.IsString()) c.aimid_ = rapidjson_get_string(i->value); }
            { auto i = node->FindMember("stamp"); if (i != node->MemberEnd() && i->value.IsString()) c.stamp_ = rapidjson_get_string(i->value); }
            { auto i = node->FindMember("type"); if (i != node->MemberEnd() && i->value.IsString()) c.type_ = rapidjson_get_string(i->value); }
            { 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_ = rapidjson_get_string(i->value); }
                    { auto i = sub_node.FindMember("lastName"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.last_name_ = rapidjson_get_string(i->value); }
                    { auto i = sub_node.FindMember("nickname"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.nick_name_ = rapidjson_get_string(i->value); }
                    { auto i = sub_node.FindMember("city"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.city_ = rapidjson_get_string(i->value); }
                    { auto i = sub_node.FindMember("state"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.state_ = rapidjson_get_string(i->value); }
                    { auto i = sub_node.FindMember("country"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.country_ = rapidjson_get_string(i->value); }
                    { auto i = sub_node.FindMember("gender"); if (i != sub_node.MemberEnd() && i->value.IsString()) c.gender_ = rapidjson_get_string(i->value); }
                    {
                        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_ = rapidjson_get_string(i->value); }
                }
                //{ auto i = node->FindMember("mutualCount"); if (i != node->MemberEnd() && i->value.IsInt()) c.score_ = i->value.GetInt(); }//TODO fix name when server side is done
            }
            contacts_data_.emplace_back(std::move(c));
        }
    }
    return true;
}