SphinxFunctionalObject.hpp

Go to the documentation of this file.

#ifndef SPHINX_FUNCTIONAL_OBJECT_HPP
#define SPHINX_FUNCTIONAL_OBJECT_HPP

#include <sstream>
#include "SphinxSearchInterface.hpp"
#include "SphinxNodeOptions.hpp"
#include "SphinxSearcher.hpp"
#include "SphinxIndexer.hpp"
#include "LoggerStream.hpp"
#include "CustomMessage.hpp"

namespace HCE
{
namespace sphinx
{
class SphinxInputJsonMessage;
class SphinxOutputJsonMessage;
//-----------------------------------------------------------------------------
class SphinxFunctionalObject : public SphinxSearchInterface, public SphinxNodeOptions
{
public:
  explicit SphinxFunctionalObject(const std::string& nodeName_="", const std::string& homeDir_=sphinx_search_const::defaultHomeDir,
      const std::string& indexName_="", bool startSearchd_=false, bool stopSearchd_=false);
  SphinxFunctionalObject(const std::string& nodeName_, unsigned int nodeNumber, const std::string& homeDir_=sphinx_search_const::defaultHomeDir,
      const std::string& indexName_="", bool startSearchd_=false, bool stopSearchd_=false);
  virtual ~SphinxFunctionalObject(void);

  bool loadConfiguration(const std::string& indexName); // indexer config
  std::string Process(const std::string& json); // make search (black box)
  SphinxOutputJsonMessage Process(SphinxInputJsonMessage& inputJsonMessage);

  void resizeResultData(size_t matchesCount, size_t attributesCount);
  bool isLoadedConfig(void) const {return loaded;};

  bool easyStart(void);
  bool startSearchd(void);
  bool stopSearchd(void);
  bool isActiveSearchd(void);
  bool isConnected(void) const;

  bool open(void);  // persistence connection
  bool close(void); // close connection

  void resetError(void);
  void applyError(const std::string& msg, unsigned int code);
  std::string getErrorMsg(void) const;
  unsigned int getErrorCode(void) const;

  void setServerHost(const std::string& serverHost_);
  std::string getServerHost(void) const;

  void setServerPort(int serverPort_);
  int getServerPort(void) const;

  bool setIndexFileName(const std::string& indexFileName_);
  std::string getIndexFileName(void) const;

  void setTimeoutedRequests(unsigned long long timeoutedRequests_);
  unsigned long long getTimeoutedRequests(void) const;
  void resetTimeoutedRequests(void);

  void setDefaultRequestTimeout(unsigned long defaultRequestTimeout_);
  unsigned long getDefaultRequestTimeout(void) const;

  void setCheckIncomingDocuments(bool checkIncomingDocuments_) {checkIncomingDocuments=checkIncomingDocuments_;}
  bool getCheckIncomingDocuments(void) const {return checkIncomingDocuments;}

  void setPackIncomingDocuments(bool packIncomingDocuments_) {packIncomingDocuments=packIncomingDocuments_;}
  bool getPackIncomingDocuments(void) const {return packIncomingDocuments;}

  void setMinNumberFieldsPacking(unsigned int minNumberFieldsPacking_) {minNumberFieldsPacking=minNumberFieldsPacking_;}
  unsigned int getMinNumberFieldsPacking(void) const {return minNumberFieldsPacking;}

  void resetLogStream(void);
  void setLogStream(std::ostream& os);

  std::string logMsg(bool isReset=true);
  std::ostream& log(LoggerStream::Priority logPriority);

  void setLoggable(Loggable loggable);
  void resetLoggable(void);

  static void parseHostPort(const std::string& in, std::string& host, unsigned int& port) throw (std::exception);

  CustomMessage& getCustomMessage(void) {return message;}

  void setMatchMode(unsigned int matchMode_) {matchMode=matchMode_;}
  unsigned int getMatchMode(void) const {return matchMode;}

  void setSortMode(unsigned int sortMode_) {sortMode=sortMode_;}
  unsigned int getSortMode(void) const {return sortMode;}

  void setRankingMode(unsigned int rankingMode_, const std::string& rankerExpression_="");
  unsigned int getRankingMode(void) const {return rankingMode;}

  void setRankerExpression(const std::string& rankerExpression_) {rankerExpression=rankerExpression_;}
  std::string getRankerExpression(void) const {return rankerExpression;}

  static std::string makeErrorMessage(const std::string& inputMessage, unsigned int errorCode, const std::string& errorMessage);
private:
  std::string makeDefaultJSON(const std::string& logMsg);
private:
  SphinxSearcher searcher;
  SphinxIndexer indexer;

  bool loaded;
  bool checkIncomingDocuments;
  bool packIncomingDocuments;
  unsigned int minNumberFieldsPacking;

  LoggerStream logger;

  MessagesCollection messagesCollection;
  CustomMessage message;

  unsigned int matchMode;
  unsigned int sortMode;
  unsigned int rankingMode;
  std::string rankerExpression;

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

#endif // SPHINX_FUNCTIONAL_OBJECT_HPP