Any plan to add move assignment operator to Json::Value

[gitpaladin]

In the master branch, Json::Value has move constructor but move assignment operator is missing. So it's very inconvenient to move a existing Value object to a parent node. E.g.

Json::Value child("abc");
Json::Value parent;

// Use swap to void deep copy node
Json::Value &parentSubNodeReference = parent["subNode"];
parentSubNodeReference.swap(child);

// If there is a move assignment operator, it will become very easy
parent["subNode"] = std::move(child);

Additionally, add move assignment operator can solve function return value deep copy problem. E.g.

Json::Value SomeAwesomeFoo()
{
   Json::Value someHugeNode;
   // process some huge node.....omitted
   return someHugeNode;
}

void main()
{
   Json::Value parent;

  // Use swap to prevent deep copy node.
  Json::Value child = SomeAwesomeFoo();  // RVO will prevent deep copy child object
  parent["subNode"].swap(child);

  // This cannot be compiled because swap cannot hold a r-value reference
  // parent["subNode"].swap(SomeAwesomeFoo()); 

  // If there is a move assignment operator, it will become very easy
  // The function return a r-value, the assignment operator will use move assignment 
  // operator to move the temporary object to the subNode
  parent["subNode"] = SomeAwesomeFoo();
}

On the other hand, append method should also have a overloaded version, which accepts r-value reference of Json::Value . So move a temporary object to a array value will come very easy.

Json::Value child("abc");
Json::Value parent(Json::arrayValue);

// Use swap to prevent deep copy node.
Json::Value &parentSubNodeReference = parent.append(Json::objectValue);
parentSubNodeReference.swap(child);

// Use r-value reference version
parent.append(std::move(child));

[cdunn2001]

@BillyDonahue, Any opinion on this? Do we need to do a version bump to add move-assignment?

[BillyDonahue]

These are all good points. It's surprising to have move construct without move assign. They arise mutually for value types.

Aside, in the above comment this line was offered as a problem:

parent["subNode"].swap(SomeAwesomeFoo());

But in classical C++ this should be written with a member call on the rvalue, as:

SomeAwesomeFoo().swap(parent["subNode"]);

Does it need a version bump? I don't know. I don't deal with versioned releases of anything very often. Let's see. Code compiled against the old header should continue to work with the new library because the operator=(Value&) will still exist before and after adding operator=(Value&&). Is that good enough?

[cdunn2001]

@gitpaladin, if you submit a PR, we'll merge it and bump the minor version. Ok?