nlohmann::basic_json::swap¶

// (1)
voidswap(referenceother)noexcept(
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value
);
// (2)
friendvoidswap(referenceleft,referenceright)noexcept(
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value
);
// (3)
voidswap(array_t&other);
// (4)
voidswap(object_t&other);
// (5)
voidswap(string_t&other);
// (6)
voidswap(binary_t&other);
// (7)
voidswap(typenamebinary_t::container_type&other);

1. Exchanges the contents of the JSON value with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
2. Exchanges the contents of the JSON value from left with those of right. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. Implemented as a friend function callable via ADL.
3. Exchanges the contents of a JSON array with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
4. Exchanges the contents of a JSON object with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
5. Exchanges the contents of a JSON string with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
6. Exchanges the contents of a binary value with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
7. Exchanges the contents of a binary value with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. Unlike version (6), no binary subtype is involved.

Parameters¶

other (in, out)

value to exchange the contents with

left (in, out)

value to exchange the contents with

right (in, out)

value to exchange the contents with

Exceptions¶

1. No-throw guarantee: this function never throws exceptions.
2. No-throw guarantee: this function never throws exceptions.
3. Throws type_error.310 if called on JSON values other than arrays; example: "cannot use swap(array_t&) with boolean"
4. Throws type_error.310 if called on JSON values other than objects; example: "cannot use swap(object_t&) with boolean"
5. Throws type_error.310 if called on JSON values other than strings; example: "cannot use swap(string_t&) with boolean"
6. Throws type_error.310 if called on JSON values other than binaries; example: "cannot use swap(binary_t&) with boolean"
7. Throws type_error.310 if called on JSON values other than binaries; example: "cannot use swap(binary_t::container_type&) with boolean"

Complexity¶

Constant.

Examples¶

#include<iostream>
#include<nlohmann/json.hpp>
usingjson=nlohmann::json;
intmain()
{
// create two JSON values
jsonj1={1,2,3,4,5};
jsonj2={{"pi",3.141592653589793},{"e",2.718281828459045}};
// swap the values
j1.swap(j2);
// output the values
std::cout<<"j1 = "<<j1<<'\n';
std::cout<<"j2 = "<<j2<<'\n';
}

j1={"e":2.718281828459045,"pi":3.141592653589793}
j2=[1,2,3,4,5]

#include<iostream>
#include<nlohmann/json.hpp>
usingjson=nlohmann::json;
intmain()
{
// create a JSON value
jsonvalue={{"array",{1,2,3,4}}};
// create an array_t
json::array_tarray={"Snap","Crackle","Pop"};
// swap the array stored in the JSON value
value["array"].swap(array);
// output the values
std::cout<<"value = "<<value<<'\n';
std::cout<<"array = "<<array<<'\n';
}

value={"array":["Snap","Crackle","Pop"]}
array=[1,2,3,4]

#include<iostream>
#include<nlohmann/json.hpp>
usingjson=nlohmann::json;
intmain()
{
// create a JSON value
jsonvalue={{"translation",{{"one","eins"},{"two","zwei"}}}};
// create an object_t
json::object_tobject={{"cow","Kuh"},{"dog","Hund"}};
// swap the object stored in the JSON value
value["translation"].swap(object);
// output the values
std::cout<<"value = "<<value<<'\n';
std::cout<<"object = "<<object<<'\n';
}

value={"translation":{"cow":"Kuh","dog":"Hund"}}
object={"one":"eins","two":"zwei"}

#include<iostream>
#include<nlohmann/json.hpp>
usingjson=nlohmann::json;
intmain()
{
// create a JSON value
jsonvalue={"the good","the bad","the ugly"};
// create string_t
json::string_tstring="the fast";
// swap the object stored in the JSON value
value[1].swap(string);
// output the values
std::cout<<"value = "<<value<<'\n';
std::cout<<"string = "<<string<<'\n';
}

value=["the good","the fast","the ugly"]
string=thebad

#include<iostream>
#include<nlohmann/json.hpp>
usingjson=nlohmann::json;
intmain()
{
// create a binary value
jsonvalue=json::binary({1,2,3});
// create a binary_t
json::binary_tbinary={{4,5,6}};
// swap the object stored in the JSON value
value.swap(binary);
// output the values
std::cout<<"value = "<<value<<'\n';
std::cout<<"binary = "<<json(binary)<<'\n';
}

value={"bytes":[4,5,6],"subtype":null}
binary={"bytes":[1,2,3],"subtype":null}

See also¶

• std::swap<basic_json>
• operator= copy assignment
• basic_json create a JSON value

Version history¶

1. Since version 1.0.0.
2. Since version 1.0.0.
3. Since version 1.0.0.
4. Since version 1.0.0.
5. Since version 1.0.0.
6. Since version 3.8.0.
7. Since version 3.8.0.