SphinxWeightCalculator.hpp

Go to the documentation of this file.

#ifndef SPHINX_WEIGHT_CALCULATOR_HPP
#define SPHINX_WEIGHT_CALCULATOR_HPP

#include <Poco/SharedPtr.h>

#include "SphinxResultData.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
class CalculateStrategy
{
public:
  enum StrategyTypes
  {
    stUseFieldNames=0
  };
public:
  CalculateStrategy(void) : logString("") {}
  virtual ~CalculateStrategy(void) {}

  virtual void calculate(const std::vector<std::string>& orderFields, SphinxResultData& resultData)=0;

  std::string getLogString(void) const {return logString;}

protected:
  static void weightToStream(const std::string& input, std::ostream& os) throw (std::exception);

  std::string logString;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class CalculateStrategyFactory
{
public:
  static Poco::SharedPtr<CalculateStrategy> create(const std::string& weightAlgirithm);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class SphinxWeightCalculator : public CalculateStrategy
{
public:
  SphinxWeightCalculator(void) :inherited(), strategy() {}
  virtual ~SphinxWeightCalculator(void) {}

  void setStrategy(Poco::SharedPtr<CalculateStrategy> strategy_) {strategy=strategy_;}
  Poco::SharedPtr<CalculateStrategy>& getStrategy(void) {return strategy;}

  void calculate(const std::vector<std::string>& orderFields, SphinxResultData& resultData);
private:
  Poco::SharedPtr<CalculateStrategy> strategy;
  typedef CalculateStrategy inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class CalculateStrategyDefault : public CalculateStrategy
{
public:
  CalculateStrategyDefault(void) : inherited() {}
  virtual ~CalculateStrategyDefault(void) {}

  void calculate(const std::vector<std::string>& orderFields, SphinxResultData& resultData);

  typedef CalculateStrategy inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class CalculateStrategyUseFieldNames : public CalculateStrategy
{
public:
  CalculateStrategyUseFieldNames(void) : inherited() {}
  virtual ~CalculateStrategyUseFieldNames(void) {}

  void calculate(const std::vector<std::string>& orderFields, SphinxResultData& resultData);

  typedef CalculateStrategy inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace sphinx 
} // namespace HCE 

#endif // SPHINX_WEIGHT_CALCULATOR_HPP