CalculatorNodeExecution.cpp

Go to the documentation of this file.

#include <sstream>
#include <iterator>
#include <algorithm>

#include <Poco/Timestamp.h>
#include <Poco/DateTimeFormatter.h>

#include "CalculatorNodeExecution.hpp"

namespace HCE
{
namespace handlers
{
//-----------------------------------------------------------------------------
CalculatorAlgorithmData::CalculatorAlgorithmData(unsigned int order_)
: inherited(), order(order_)
{
}
//-----------------------------------------------------------------------------
CalculatorAlgorithmData::CalculatorAlgorithmData(const CalculatorAlgorithmData& rhs)
: inherited(), order(0)
{
  (*this) = rhs;
}
//-----------------------------------------------------------------------------
CalculatorAlgorithmData::CalculatorAlgorithmData(CalculatorAlgorithmData&& rhs)
: inherited(), order(0)
{
  (*this) = std::forward<CalculatorAlgorithmData>(rhs);
}
//-----------------------------------------------------------------------------
CalculatorAlgorithmData& CalculatorAlgorithmData::operator=(const CalculatorAlgorithmData& rhs)
{
  if (this!=&rhs)
  {
    order = rhs.getOrder();
    items = rhs.getItems();
  }
  return *this;
}
//-----------------------------------------------------------------------------
CalculatorAlgorithmData& CalculatorAlgorithmData::operator=(CalculatorAlgorithmData&& rhs)
{
  if (this!=&rhs)
  {
    order = std::move(rhs.getOrder());
    items = std::move(rhs.getItems());
  }
  return *this;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CalculatorNodeResourceData::CalculatorNodeResourceData(const std::string& identity_)
: inherited(), identity(identity_)
{
}
//-----------------------------------------------------------------------------
CalculatorNodeResourceData::CalculatorNodeResourceData(const CalculatorNodeResourceData& rhs)
: inherited(), identity("")
{
  (*this) = rhs;
}
//-----------------------------------------------------------------------------
CalculatorNodeResourceData::CalculatorNodeResourceData(CalculatorNodeResourceData&& rhs)
: inherited(), identity("")
{
  (*this) = std::forward<CalculatorNodeResourceData>(rhs);
}
//-----------------------------------------------------------------------------
CalculatorNodeResourceData& CalculatorNodeResourceData::operator=(const CalculatorNodeResourceData& rhs)
{
  if (this!=&rhs)
  {
    identity = rhs.getIdentity();
    items = rhs.getItems();
  }
  return *this;
}
//-----------------------------------------------------------------------------
CalculatorNodeResourceData& CalculatorNodeResourceData::operator=(CalculatorNodeResourceData&& rhs)
{
  if (this!=&rhs)
  {
    identity = std::move(rhs.getIdentity());
    items = std::move(rhs.getItems());
  }
  return *this;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CalculatorAlgorithmDefault::CalculatorAlgorithmDefault(void)
:inherited()
{
}
//-----------------------------------------------------------------------------
std::string CalculatorAlgorithmDefault::calculate(const CalculatorAlgorithmData& algorithmData, NodeResourceDataList& nodeDataList, ResourceUsageManager& resourceUsageManager)
{
  std::string identity;
  std::vector<std::pair<std::string, double> > weights; // pair content: first is identity, second is accumulated weigth for this adentity

  for (size_t i=0;i<nodeDataList.getItemsCount();++i)
  {
    double weight = 0.0;
    for (CalculatorAlgorithmData::ConstIterator iter=algorithmData.begin();iter!=algorithmData.end();++iter)
    {
      weight += (const_cast<CalculatorNodeResourceData&>(nodeDataList.getItem(i)).getItem((*iter).first) * (*iter).second);
    }
    weights.push_back(std::make_pair(nodeDataList.getItem(i).getIdentity(), weight));

    resourceUsageManager.setLastWeight(nodeDataList.getItem(i).getIdentity(), weight);
  }

  std::function<bool(std::pair<std::string, double>, std::pair<std::string, double>)> comp;
  if (algorithmData.getOrder())
    comp = [](std::pair<std::string, double> lhs, std::pair<std::string, double> rhs){ return (lhs.second>rhs.second);};
  else
    comp = [](std::pair<std::string, double> lhs, std::pair<std::string, double> rhs){ return (lhs.second<rhs.second);};

  std::sort(weights.begin(), weights.end(), comp);

  if (!weights.empty())
  {
    if (weights.front().second != weights.back().second)
    {
      identity = weights[0].first;
    }
  }
  return identity;
}
//-----------------------------------------------------------------------------
std::vector<double> CalculatorAlgorithmDefault::getListWeights(const CalculatorAlgorithmData& algorithmData, ResourceUsageCollection& collection)
{
  std::vector<double> listWeights;
  for (ResourceUsageCollection::iterator iT=collection.begin();iT!=collection.end();++iT)
  {
    double weight = 0.0;
    for (CalculatorAlgorithmData::ConstIterator iter=algorithmData.begin();iter!=algorithmData.end();++iter)
    {
      weight += ((*iT).getItem((*iter).first) * (*iter).second);
    }
    listWeights.push_back(weight);
  }
  return listWeights;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CalculatorNodeExecution::CalculatorNodeExecution(CalculatorAlgorithm::Types type)
: algorithm(nullptr)
{
  algorithm = createAlgorithm(type);
}
//-----------------------------------------------------------------------------
std::string CalculatorNodeExecution::calculate(const CalculatorAlgorithmData& algorithmData, NodeResourceDataList& nodeDataList, ResourceUsageManager& resourceUsageManager)
{
  std::string identity;
  if (!algorithm.isNull())
  {
    identity = algorithm->calculate(algorithmData, nodeDataList, resourceUsageManager);
  }
  return identity;
}
//-----------------------------------------------------------------------------
std::vector<double> CalculatorNodeExecution::getListWeights(const CalculatorAlgorithmData& algorithmData, ResourceUsageCollection& collection)
{
  std::vector<double> listWeights;
  if (!algorithm.isNull())
  {
    listWeights = algorithm->getListWeights(algorithmData, collection);
  }
  return listWeights;
}
//-----------------------------------------------------------------------------
Poco::SharedPtr<CalculatorAlgorithm> CalculatorNodeExecution::createAlgorithm(CalculatorAlgorithm::Types type)
{
  Poco::SharedPtr<CalculatorAlgorithm> pAlg = nullptr;
  switch(type)
  {
    case CalculatorAlgorithm::Types::caDefault: pAlg = new CalculatorAlgorithmDefault();
      break;
    //TODO add next algorithm types
    default: pAlg = new CalculatorAlgorithmDefault();
  }
  return pAlg;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace handlers
} // end namespace HCE