/**
* \brief Synchronizes all copies of this vertex
*
* If the current vertex value has changed, copy the vertex value to
* all mirrors. This is for advanced use!
* Under most circumstances you should not need to use
* this function directly.
*/
void synchronize() {
if (vtx_set && graph.l_is_master(vtx.local_id())) {
std::string new_value = serialize_to_string(vtx.data());
if (original_value != new_value) {
// synchronize this vertex's value
engine.synchronize_one_vertex_wait(vtx);
}
std::swap(original_value, new_value);
}
}
std::string variant::string_cast() const
{
switch(type_) {
case TYPE_NULL:
return "0";
case TYPE_INT:
return boost::lexical_cast<std::string>(int_value_);
case TYPE_DECIMAL: {
std::string res;
serialize_to_string(res);
return res;
}
case TYPE_CALLABLE_LOADING:
return "(object loading)";
case TYPE_CALLABLE:
return "(object)";
case TYPE_LIST: {
std::string res = "";
for(size_t i=0; i<list_->elements.size(); ++i) {
const variant& var = list_->elements[i];
if(!res.empty()) {
res += ", ";
}
res += var.string_cast();
}
return res;
}
case TYPE_MAP: {
std::string res = "";
for(std::map<variant,variant>::const_iterator i=map_->elements.begin(); i != map_->elements.end(); ++i) {
if(!res.empty()) {
res += ",";
}
res += i->first.string_cast();
res += "->";
res += i->second.string_cast();
}
return res;
}
case TYPE_STRING:
return string_->str;
default:
assert(false);
return "invalid";
}
}
void serialize(std::string& str) const {
serialize_to_string(str);
}
IOBuffer HttpResponse::serialize_to_buffer()
{
return IOBuffer(serialize_to_string());
}
/**
* \internal
* \brief Flags that this vertex was synchronized.
*/
void set_synchronized() {
if (vtx_set && graph.l_is_master(vtx.local_id())) {
original_value = serialize_to_string(vtx.data());
}
}
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());
}
