int AccessStatInfoMessage::set_counter_map(common::Stream& output, const COUNTER_TYPE & map, int32_t from_row,
int32_t return_row, int32_t size) const
{
int32_t iret = output.set_int32(size);
if (common::TFS_SUCCESS == iret)
{
if (size > 0)
{
int64_t pos = 0;
int32_t count = 0;
COUNTER_TYPE::const_iterator iter = map.begin();
for (; iter != map.end(); ++iter, ++count)
{
if (count <= from_row)
continue;
if (count > from_row + return_row)
break;
iret = output.set_int32(iter->first);
if (common::TFS_SUCCESS != iret)
break;
pos = 0;
iret = const_cast<common::Throughput*>(&iter->second)->serialize(output.get_free(), output.get_free_length(), pos);
if (common::TFS_SUCCESS == iret)
output.pour(iter->second.length());
else
break;
}
}
}
return iret;
}
int AccessStatInfoMessage::set_counter_map(char** data, int32_t* len, const COUNTER_TYPE & map, int32_t from_row,
int32_t return_row, int32_t size)
{
if (set_int32(data, len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
if (size <= 0)
{
return TFS_SUCCESS;
}
int count = 0;
COUNTER_TYPE::const_iterator it = map.begin();
for (; it != map.end(); ++it)
{
count++;
if (count <= from_row)
{
continue;
}
if (count > from_row + return_row)
{
break;
}
if (set_int32(data, len, static_cast<int32_t> (it->first)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_object(data, len, reinterpret_cast<void*> (const_cast<Throughput*>(&it->second)), sizeof(Throughput)) == TFS_ERROR)
{
return TFS_ERROR;
}
}
return TFS_SUCCESS;
}
int ReplicateInfoMessage::set_counter_map(char** data, int32_t* len, const COUNTER_TYPE & map, int32_t size)
{
if (set_int32(data, len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
for (COUNTER_TYPE::const_iterator it = map.begin(); it != map.end(); ++it)
{
if (set_int64(data, len, static_cast<int64_t> (it->first)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int32(data, len, static_cast<int32_t> (it->second)) == TFS_ERROR)
{
return TFS_ERROR;
}
size--;
if (size <= 0)
{
break;
}
}
return TFS_SUCCESS;
}
int AccessStatInfoMessage::get_counter_map(common::Stream& input, COUNTER_TYPE & map)
{
int32_t size = 0;
int32_t iret = input.get_int32(&size);
if (common::TFS_SUCCESS == iret)
{
common::Throughput t;
int64_t pos = 0;
int32_t id = 0;
for (int32_t i = 0; i < size; ++i)
{
iret = input.get_int32(&id);
if (common::TFS_SUCCESS != iret)
break;
pos = 0;
iret = t.deserialize(input.get_data(), input.get_data_length(), pos);
if (common::TFS_SUCCESS != iret)
break;
else
{
input.drain(t.length());
map.insert(COUNTER_TYPE::value_type(id, t));
}
}
}
return iret;
}
int ReplicateInfoMessage::get_counter_map(char** data, int32_t* len, COUNTER_TYPE & m)
{
int32_t i = 0;
int32_t size = 0;
uint64_t server_id = 0;
uint32_t count = 0;
if (get_int32(data, len, &size) == TFS_ERROR)
{
return TFS_ERROR;
}
for (i = 0; i < size; ++i)
{
if (get_int64(data, len, reinterpret_cast<int64_t*> (&server_id)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_int32(data, len, reinterpret_cast<int32_t*> (&count)) == TFS_ERROR)
{
return TFS_ERROR;
}
m.insert(COUNTER_TYPE::value_type(server_id, count));
}
return TFS_SUCCESS;
}
int AccessStatInfoMessage::get_counter_map(char** data, int32_t* len, COUNTER_TYPE & map)
{
int32_t i = 0;
int32_t size = 0;
uint32_t server_id = 0;
Throughput count;
if (get_int32(data, len, &size) == TFS_ERROR)
return TFS_ERROR;
for (i = 0; i < size; ++i)
{
if (get_int32(data, len, (int32_t*) &server_id) == TFS_ERROR)
return TFS_ERROR;
if (get_object_copy(data, len, reinterpret_cast<void*> (&count), sizeof(Throughput)) == TFS_ERROR)
{
return TFS_ERROR;
}
map.insert(COUNTER_TYPE::value_type(server_id, count));
}
return TFS_SUCCESS;
}
