variant variant::operator+(const variant& v) const
{
if(type_ == TYPE_INT && v.type_ == TYPE_INT) {
//strictly an optimization -- this is handled below, but the case
//of adding two integers is the most common so we want it to be fast.
return variant(int_value_ + v.int_value_);
}
if(type_ == TYPE_STRING) {
if(v.type_ == TYPE_MAP) {
return variant(as_string() + v.as_string());
} else if(v.type_ == TYPE_STRING) {
return variant(as_string() + v.as_string());
}
std::string s;
v.serialize_to_string(s);
return variant(as_string() + s);
}
if(v.type_ == TYPE_STRING) {
std::string s;
serialize_to_string(s);
return variant(s + v.as_string());
}
if(type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL) {
return variant(as_decimal() + v.as_decimal());
}
if(type_ == TYPE_INT) {
return variant(int_value_ + v.as_int());
}
if(type_ == TYPE_NULL) {
return v;
} else if(v.type_ == TYPE_NULL) {
return *this;
}
if(type_ == TYPE_LIST) {
if(v.type_ == TYPE_LIST) {
std::vector<variant> res;
res.reserve(list_->elements.size() + v.list_->elements.size());
for(size_t i = 0; i<list_->elements.size(); ++i) {
const variant& var = list_->elements[i];
res.push_back(var);
}
for(size_t j = 0; j<v.list_->elements.size(); ++j) {
const variant& var = v.list_->elements[j];
res.push_back(var);
}
return variant(&res);
}
}
if(type_ == TYPE_MAP) {
if(v.type_ == TYPE_MAP) {
std::map<variant,variant> res(map_->elements);
for(std::map<variant,variant>::const_iterator i = v.map_->elements.begin(); i != v.map_->elements.end(); ++i) {
res[i->first] = i->second;
}
return variant(&res);
}
}
return variant(as_int() + v.as_int());
}
