CalculatorNodeExecution.hpp

Go to the documentation of this file.

#ifndef CALCULATOR_NODE_EXECUTION_HPP
#define CALCULATOR_NODE_EXECUTION_HPP

#include <Poco/SharedPtr.h>

#include "DRCECommonList.hpp"
#include "Dictionary.hpp"
#include "ResourceUsageManager.hpp"

namespace HCE
{
namespace handlers
{
//-----------------------------------------------------------------------------
class CalculatorAlgorithmData : public Dictionary <std::string, double>
{
  static const char DELIMITER = ',';
public:
  explicit CalculatorAlgorithmData(unsigned int order_=0);
  CalculatorAlgorithmData(const CalculatorAlgorithmData& rhs);
  CalculatorAlgorithmData(CalculatorAlgorithmData&& rhs);
  ~CalculatorAlgorithmData(void) {}

  CalculatorAlgorithmData& operator=(const CalculatorAlgorithmData& rhs);
  CalculatorAlgorithmData& operator=(CalculatorAlgorithmData&& rhs);

  void setOrder(unsigned int order_) {order=order_;}
  unsigned int getOrder(void) const {return order;}
private:
  unsigned int order; 

  typedef Dictionary <std::string, double> inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class CalculatorNodeResourceData : public Dictionary <std::string, double>
{
public:
  explicit CalculatorNodeResourceData(const std::string& identity_="");
  CalculatorNodeResourceData(const CalculatorNodeResourceData& rhs);
  CalculatorNodeResourceData(CalculatorNodeResourceData&& rhs);
  ~CalculatorNodeResourceData(void) {}

  CalculatorNodeResourceData& operator=(const CalculatorNodeResourceData& rhs);
  CalculatorNodeResourceData& operator=(CalculatorNodeResourceData&& rhs);

  void setIdentity(const std::string& identity_) {identity=identity_;}
  std::string getIdentity(void) const {return identity;}
private:
  std::string identity;

  typedef Dictionary <std::string, double> inherited;
};
//-----------------------------------------------------------------------------
typedef HCE::drce::DRCECommonList <CalculatorNodeResourceData> NodeResourceDataList;
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class CalculatorAlgorithm
{
public:
  enum class Types
  {
    caDefault=0
  };

  CalculatorAlgorithm(void) {}
  virtual ~CalculatorAlgorithm(void) {}

  virtual std::string calculate(const CalculatorAlgorithmData& algorithmData, NodeResourceDataList& nodeDataList, ResourceUsageManager& resourceUsageManager) = 0;
  virtual std::vector<double> getListWeights(const CalculatorAlgorithmData& algorithmData, ResourceUsageCollection& collection)=0;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class CalculatorAlgorithmDefault : public CalculatorAlgorithm
{
public:
  CalculatorAlgorithmDefault(void);
  virtual ~CalculatorAlgorithmDefault(void) {}

  std::string calculate(const CalculatorAlgorithmData& algorithmData, NodeResourceDataList& nodeDataList, ResourceUsageManager& resourceUsageManager);
  std::vector<double> getListWeights(const CalculatorAlgorithmData& algorithmData, ResourceUsageCollection& collectionr);
private:
  typedef CalculatorAlgorithm inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class CalculatorNodeExecution
{
public:
  explicit CalculatorNodeExecution(CalculatorAlgorithm::Types type=CalculatorAlgorithm::Types::caDefault);
  virtual ~CalculatorNodeExecution(void) {}

  std::string calculate(const CalculatorAlgorithmData& algorithmData, NodeResourceDataList& nodeDataList, ResourceUsageManager& resourceUsageManager);
  std::vector<double> getListWeights(const CalculatorAlgorithmData& algorithmData, ResourceUsageCollection& collection);

private:
  Poco::SharedPtr<CalculatorAlgorithm> createAlgorithm(CalculatorAlgorithm::Types type);
private:
  Poco::SharedPtr<CalculatorAlgorithm> algorithm;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace handlers
} // end namespace HCE 

#endif // CALCULATOR_NODE_EXECUTION_HPP