cpp RapidJSON - 在不丢失信息的情况下解决密钥冲突

Question

我想解析一个类似于 JSON 的文本文件。经过一些字符转换后，它仍然有一些对象，这些对象存在键冲突。所以我的 JSON 看起来像这样：

{
    "key1": {
        "a": "asdf",
        "a": "foo",
        "a": "bar",
        "a": "fdas"
    }
}

我想将其解析为：

{
    "key1": {
        "a": [
            "asdf",
            "foo",
            "bar",
            "fdas"
        ]
    }
}

我尝试使用 JsonCpp 实现此目的，但它无法处理键冲突。所以我选择使用RapidJSON，特别是因为它可以在解析时保留所有的key-conflict-members。

为了在不丢失信息的情况下解决密钥冲突，我编写了以下递归 RapidJSON cpp 代码：

void resolveKeyConflicts(rj::Value& value) {
    if (value.IsObject()) {
        std::map<std::string, unsigned int> nameCount;
        for (rj::Value::MemberIterator vMIt = value.MemberBegin();
                vMIt != value.MemberEnd(); vMIt++) {
            std::string name(vMIt->name.GetString());
            if (nameCount.find(name) == nameCount.end()) {
                nameCount[name] = 1;
            } else {
                nameCount[name] += 1;
            }
        }

        for (std::map<std::string, unsigned int>::iterator nCIt =
                nameCount.begin(); nCIt != nameCount.end(); nCIt++) {
            if (nCIt->second > 1) {
                rj::Value newArray(rj::kArrayType);
                for (rj::Value::MemberIterator vFMIt = value.FindMember(
                        nCIt->first.c_str()); vFMIt != value.MemberEnd();
                        vFMIt++) {
                    if (vFMIt->name.GetString() == nCIt->first) {
                        rj::Value value(vFMIt->value, this->GetAllocator());
                        newArray.PushBack(value, this->GetAllocator());
                    }
                }

                value.EraseMember(value.FindMember(nCIt->first.c_str()),
                        value.MemberEnd());
                rj::Value key(nCIt->first.c_str(), nCIt->first.length(),
                        this->GetAllocator());
                value.AddMember(key, newArray, this->GetAllocator());
            }
        }

        for (rj::Value::MemberIterator vMIt = value.MemberBegin();
                vMIt != value.MemberEnd(); vMIt++) {
            if (vMIt->value.IsObject() || vMIt->value.IsArray()) {
                resolveKeyConflicts(vMIt->value);
            }
        }
    } else if (value.IsArray()) {
        for (rj::Value::ValueIterator vVIt = value.Begin(); vVIt != value.End();
                vVIt++) {
            resolveKeyConflicts(*vVIt);
        }
    }
}

只要冲突的关键成员是该对象中的唯一成员，这就非常有效。我认为，这可以用更简单的代码进行归档，但我还尝试能够像这样解决任意键冲突：

{
    "key2": {
        "a": "asdf",
        "b": "foo",
        "b": "bar",
        "c": "fdas"
    }
}

进入这个：

{
    "key2": {
        "a": "asdf",
        "b": [
            "foo",
            "bar"
        ],
        "c": "fdas"
    }
}

原来 FindMember 并没有像我想的那样返回一个遍历所有具有相同键名的成员的迭代器，而只是返回具有该键的第一个成员的位置。我认为我的 python 思维方式可能与我对 FindMember 的期望相悖。所以像这样，代码将失去 "c": "fdas" 成员。

我依赖 MemberIterator EraseMember(MemberIterator first, MemberIterator last)，因为 http://rapidjson.org/md_doc_tutorial.html#ModifyObject 中提到的所有其他删除成员的方法似乎都无法删除 key1 案例中的最后一个成员。但是像这样的EraseMember绝对是key2情况下的错误选择。

所以我有点迷路了。请有人指出正确的方向来解决关键冲突而不丢失信息，这可以处理 key1 和 key2 情况？

编辑：我正在使用来自 https://github.com/miloyip/rapidjson/tree/v1.0.2 的 RapidJSON，它位于 v1.0.2 标签。

Answer 1

我完全重写了那部分，（再次）尝试另一种方法。我想我找到了一个非常优雅的解决方案：

void resolveKeyConflicts(rj::Value& value) {
    if (value.IsObject()) {
        std::vector<std::string> resolvedConflicts;
        rj::Value newValue(rj::kObjectType);
        for (rj::Value::MemberIterator vMIt = value.MemberBegin();
                vMIt != value.MemberEnd(); vMIt++) {
            rj::Value::MemberIterator nVFMIt = newValue.FindMember(vMIt->name);
            if (nVFMIt == newValue.MemberEnd()) {
                rj::Value newKey(vMIt->name, this->GetAllocator());
                newValue.AddMember(newKey, vMIt->value, this->GetAllocator());
            } else {
                std::string conflict(vMIt->name.GetString(),
                        vMIt->name.GetStringLength());
                if (std::find(resolvedConflicts.begin(),
                        resolvedConflicts.end(), conflict)
                        == resolvedConflicts.end()) {
                    rj::Value newArray(rj::kArrayType);
                    nVFMIt->value.Swap(newArray);
                    nVFMIt->value.PushBack(newArray, this->GetAllocator());
                    nVFMIt->value.PushBack(vMIt->value, this->GetAllocator());

                    resolvedConflicts.push_back(conflict);
                } else {
                    nVFMIt->value.PushBack(vMIt->value, this->GetAllocator());
                }
            }
        }

        value.SetNull().SetObject();
        for (rj::Value::MemberIterator nVMIt = newValue.MemberBegin();
                nVMIt != newValue.MemberEnd(); nVMIt++) {
            if (nVMIt->value.IsObject() || nVMIt->value.IsArray()) {
                this->resolveKeyConflicts(nVMIt->value);
            }
            value.AddMember(nVMIt->name, nVMIt->value, this->GetAllocator());
        }
    } else if (value.IsArray()) {
        for (rj::Value::ValueIterator vVIt = value.Begin(); vVIt != value.End();
                vVIt++) {
            if (vVIt->IsObject() || vVIt->IsArray()) {
                this->resolveKeyConflicts(*vVIt);
            }
        }
    }
}

我不太确定 value.SetNull().SetObject() 用于清空 value 的部分，但它确实有效。

如果您认为有改进的余地，请告诉我哪里。谢谢

Answer 2

我觉得比较棘手的是要记住key是否已经展开为数组（因为value可能本来就是数组）

因此，另一种方法是先将所有key: value转换为key:[value]，进行合并，如果数组中只有一个元素，则转换回key: value。

这是我的尝试：

static void MergeDuplicateKey(Value& v, Value::AllocatorType& a) {
    if (v.IsObject()) {
        // Convert all key:value into key:[value]
        for (Value::MemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr)
            itr->value = Value(kArrayType).Move().PushBack(itr->value, a);

        // Merge arrays if key is duplicated
        for (Value::MemberIterator itr = v.MemberBegin(); itr != v.MemberEnd();) {
            Value::MemberIterator itr2 = v.FindMember(itr->name);
            if (itr != itr2) {
                itr2->value.PushBack(itr->value[0], a);
                itr = v.EraseMember(itr);
            }
            else
                ++itr;
        }

        // Convert key:[values] back to key:value if there is only one value
        for (Value::MemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr) {
            if (itr->value.Size() == 1)
                itr->value = itr->value[0];
            MergeDuplicateKey(itr->value, a); // Recursion on the value
        }
    }
    else if (v.IsArray())
        for (Value::ValueIterator itr = v.Begin(); itr != v.End(); ++itr)
            MergeDuplicateKey(*itr, a);
}

我在this commit测试过。

cpp RapidJSON - 在不丢失信息的情况下解决密钥冲突

cpp RapidJSON - Resolve key conflicts without information loss

c++

json

rapidjson