void swap(Value &a, Value &b)
{
using std::swap;
swap(a.type_, b.type_);
swap(a.data_, b.data_);
}
SeparateChainingHashTable(SeparateChainingHashTable&& other) noexcept
: SeparateChainingHashTable()
{
swap(other);
}
/**
* Standard swap function.
*/
friend void swap(self& lhs, self& rhs) {
using std::swap;
swap(lhs.mean_state,rhs.mean_state);
swap(lhs.E_inv,rhs.E_inv);
swap(lhs.factor,rhs.factor);
};
void layer::swap(layer& rhs)
{
using std::swap;
swap(name_, rhs.name_);
swap(srs_, rhs.srs_);
swap(min_zoom_, rhs.min_zoom_);
swap(max_zoom_, rhs.max_zoom_);
swap(active_, rhs.active_);
swap(queryable_, rhs.queryable_);
swap(clear_label_cache_, rhs.clear_label_cache_);
swap(cache_features_, rhs.cache_features_);
swap(group_by_, rhs.group_by_);
swap(styles_, rhs.styles_);
swap(ds_, rhs.ds_);
swap(buffer_size_, rhs.buffer_size_);
swap(maximum_extent_, rhs.maximum_extent_);
}
vertex_array( vertex_array&& other ) : id(invalid_id) { swap(*this, other); }
void parent_info::swap(parent_info& other) noexcept {
using std::swap;
swap(name_, other.name_);
swap(namespaces_, other.namespaces_);
swap(properties_, other.properties_);
}
assistant& assistant::operator=(assistant other) {
using std::swap;
swap(*this, other);
return *this;
}
SGWu& SGWu::operator=(SGWu src_obj) {
swap(*this, src_obj);
return *this;
}
SGWu::SGWu(SGWu &&src_obj)
:SGWu() {
swap(*this, src_obj);
}
TunUdata& TunUdata::operator=(TunUdata src_obj) {
swap(*this, src_obj);
return *this;
}
TunUdata::TunUdata(TunUdata &&src_obj)
:TunUdata() {
swap(*this, src_obj);
}
url &url::operator =(const url &other)
{
url tmp(other);
swap(p, tmp.p);
return *this;
}
url &url::operator =(url &&other)
{
using std::swap;
swap(p, other.p);
return *this;
}
url::url(url &&other)
{
using std::swap;
swap(p, other.p);
}
void time_series_unversioned_key::swap(time_series_unversioned_key& other) noexcept {
using std::swap;
swap(id_, other.id_);
}
void parent::swap(parent& other) noexcept {
using std::swap;
swap(prop_0_, other.prop_0_);
}
time_series_unversioned_key& time_series_unversioned_key::operator=(time_series_unversioned_key other) {
using std::swap;
swap(*this, other);
return *this;
}
class_b& class_b::operator=(class_b other) {
using std::swap;
swap(*this, other);
return *this;
}
parent_info& parent_info::operator=(parent_info other) {
using std::swap;
swap(*this, other);
return *this;
}
void swap(counting_iterator& other) {
using std::swap;
swap(current_, other.current_);
}
layer& layer::operator=(layer const& rhs)
{
layer tmp(rhs);
swap(tmp);
return *this;
}
void swap(stable_priority_queue<Type> &that) {
using std::swap;
swap(sequence_, that.sequence_);
swap(compare_, that.compare_);
swap(heap_, that.heap_);
}
friend void swap( vertex_array& lhs, vertex_array& rhs )
{
using std::swap;
swap(lhs.id, rhs.id);
}
String::String( String && other )
{
Initialize();
swap( std::move( other ) );
}
vertex_array& operator=( vertex_array lhs ) { swap(*this, lhs); return *this; }
String & String::operator=( String && other )
{
swap( std::move( other ) );
return *this;
}
SeparateChainingHashTable& operator=(SeparateChainingHashTable other)
{
swap(other);
return *this;
}
location& location::operator=(location other) {
using std::swap;
swap(*this, other);
return *this;
}
/**
* Standard assignment operator.
*/
self& operator=(self rhs) {
swap(*this,rhs);
return *this;
};
Value &Value::operator=(const Value &value)
{
Value copy = value;
swap(copy, *this);
return *this;
}
