BalancePlan.cc

Go to the documentation of this file.

#include <Common/Compat.h>

#include "BalancePlan.h"

#include <Common/Serialization.h>

#include <iostream>

using namespace std;
using namespace Hypertable;

BalancePlan::BalancePlan(const BalancePlan &other) {
  algorithm = other.algorithm;
  duration_millis = other.duration_millis;
  for (auto & move : other.moves)
    moves.push_back( make_shared<RangeMoveSpec>(*move) );
}

uint8_t BalancePlan::encoding_version() const {
  return 1;
}

size_t BalancePlan::encoded_length_internal() const {
  size_t length = 8;
  length += Serialization::encoded_length_vstr(algorithm);
  for (auto &move : moves)
    length += move->encoded_length();
  return length;
}

void BalancePlan::encode_internal(uint8_t **bufp) const {
  Serialization::encode_vstr(bufp, algorithm);
  Serialization::encode_i32(bufp, duration_millis);
  Serialization::encode_i32(bufp, moves.size());
  for (auto &move : moves)
    move->encode(bufp);
}

void BalancePlan::decode_internal(uint8_t version, const uint8_t **bufp,
                                  size_t *remainp) {
  RangeMoveSpecPtr move_spec;
  algorithm = Serialization::decode_vstr(bufp, remainp);
  duration_millis = Serialization::decode_i32(bufp, remainp);
  size_t count = Serialization::decode_i32(bufp, remainp);
  moves.reserve(count);
  for (size_t i=0; i<count; i++) {
    move_spec = make_shared<RangeMoveSpec>();
    move_spec->decode(bufp, remainp);
    moves.push_back(move_spec);
  }
}

ostream &Hypertable::operator<<(ostream &os, const BalancePlan &plan) {
  os << "{BalancePlan:";
  for (size_t i=0; i<plan.moves.size(); i++)
    os << " " << (*plan.moves[i]);
  os << " algorithm =" << plan.algorithm;
  os << " duration_millis=" << plan.duration_millis << "}";
  return os;
}