ClientWorkerItem.cpp

Go to the documentation of this file.

#include <utility>

#include "zhelpers.hpp"
#include "ClientWorkerItem.hpp"

namespace HCE
{
namespace handlers
{
//-----------------------------------------------------------------------------
TimeoutShiftCounter::TimeoutShiftCounter(void)
: rcounter(0), rdiff(0), shift(0)
{
}
//-----------------------------------------------------------------------------
TimeoutShiftCounter& TimeoutShiftCounter::operator=(const TimeoutShiftCounter& rhs)
{
  if (this!=&rhs)
  {
    rcounter = rhs.getRcounter();
    rdiff = rhs.getRdiff();
    shift = rhs.getShift();
  }
  return *this;
}
//-----------------------------------------------------------------------------
TimeoutShiftCounter& TimeoutShiftCounter::operator=(TimeoutShiftCounter&& rhs)
{
  if (this!=&rhs)
  {
    rcounter = std::move(rhs.getRcounter());
    rdiff = std::move(rhs.getRdiff());
    shift = std::move(rhs.getShift());
  }
  return *this;

}
//-----------------------------------------------------------------------------
void TimeoutShiftCounter::reset(void)
{
  rcounter = 0;
  rdiff = 0;
  shift = 0;
}
//-----------------------------------------------------------------------------
void TimeoutShiftCounter::responceTimeStamp(size_t rtimestamp)
{
  size_t delta = abs(s_clock() - rtimestamp);
  if (delta)
  {
    rdiff += delta;
    ++rcounter;
  }
//        std::stringstream outMsg;
//        outMsg << "TimeoutShiftCounter::recountDiff  rtimestamp= " << rtimestamp
//            << " (s_clock() - rtimestamp)= " << delta << " rdiff= " << rdiff << " rcounter= " << rcounter;
//        Poco::Logger::root().information(outMsg.str());
}
//-----------------------------------------------------------------------------
void TimeoutShiftCounter::recount(unsigned int timeout)
{
  double avgdiff = 0.0;
  if (rcounter)
    avgdiff = static_cast<double>(rdiff) / rcounter;

//        std::stringstream outMsg;
//        outMsg << "TimeoutShiftCounter::recountShift  rdiff= " << rdiff << " rcounter= " << rcounter << " avgdiff= " << avgdiff  << " timeout= " << timeout << " shift= " << shift;
//        Poco::Logger::root().information(outMsg.str());

  if (avgdiff > timeout)
  {
    shift = abs(avgdiff-timeout);
    if (shift>timeout)
      shift = timeout;
  }
  else
  {
    shift = avgdiff;
  }
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
ClientWorkerItem::ClientWorkerItem(void)
: identity(""), expiry(0), frequency(0), count(0), route(), resources(), rtimestamp(s_clock()),
  shiftCounter(), property(""), cpu(0.0), iowait(0.0)
{
}
//-----------------------------------------------------------------------------
ClientWorkerItem::ClientWorkerItem(const std::string& identity_, int64_t expiry_, unsigned long long frequency_, unsigned long long count_)
: identity(identity_), expiry(expiry_), frequency(frequency_), count(count_), route(), resources(), rtimestamp(s_clock()),
  shiftCounter(), property(""), cpu(0.0), iowait(0.0)
{
}
//-----------------------------------------------------------------------------
ClientWorkerItem::ClientWorkerItem(const ClientWorkerItem& rhs)
: identity(""), expiry(0), frequency(0), count(0), route(), resources(), rtimestamp(s_clock()),
  shiftCounter(), property(""), cpu(0.0), iowait(0.0)
{
  (*this) = rhs;
}
//-----------------------------------------------------------------------------
ClientWorkerItem::ClientWorkerItem(ClientWorkerItem&& rhs)
: identity(""), expiry(0), frequency(0), count(0), route(), resources(), rtimestamp(s_clock()),
  shiftCounter(), property(""), cpu(0.0), iowait(0.0)
{
  (*this) = std::forward<ClientWorkerItem>(rhs);
}
//-----------------------------------------------------------------------------
ClientWorkerItem& ClientWorkerItem::operator=(const ClientWorkerItem& rhs)
{
  if (this!=&rhs)
  {
    identity = rhs.identity;
    expiry = rhs.expiry;
    frequency = rhs.frequency;
    count = rhs.count;
    route = rhs.route;
    resources = rhs.resources;
    rtimestamp = rhs.rtimestamp;
    shiftCounter = rhs.shiftCounter;
    property = rhs.property;
    cpu = rhs.cpu;
    iowait = rhs.iowait;
  }
  return *this;
}
//-----------------------------------------------------------------------------
ClientWorkerItem& ClientWorkerItem::operator=(ClientWorkerItem&& rhs)
{
  if (this!=&rhs)
  {
    identity = std::move(rhs.identity);
    expiry = std::move(rhs.expiry);
    frequency = std::move(rhs.frequency);
    count = std::move(rhs.count);
    route = std::move(rhs.route);
    resources = std::move(rhs.resources);
    rtimestamp = std::move(rhs.rtimestamp);
    shiftCounter = std::move(rhs.shiftCounter);
    property = std::move(rhs.property);
    cpu = std::move(rhs.cpu);
    iowait = std::move(rhs.iowait);
  }
  return *this;
}
//-----------------------------------------------------------------------------
void ClientWorkerItem::clear(void)
{
  identity.clear();
  expiry = 0;
  frequency = 0;
  count = 0;
  route.clear();
  resources.clear();
  rtimestamp = s_clock();
  shiftCounter.reset();
  property.clear();
  cpu = 0.0;
  iowait = 0.0;
}
//-----------------------------------------------------------------------------
bool ClientWorkerItem::sortByFrequencyPredicate(const ClientWorkerItem& d1, const ClientWorkerItem& d2)
{
  return d1.frequency < d2.frequency;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace handlers
} // end namespace HCE