main2.cpp

Go to the documentation of this file.

#include <ReducingHandler.h>
#include <ReducingPartsCountersStorage.h>
#include <ReducingOutputMessageBuilder.h>
#include <ConsoleSupportNotifier.h>
#include <ReducingExceptionsTranslator.h>
#include <SphinxTaskReducersManagerBuilder.h>
#include <PocoJSONReducingInputMessageConvertor.h>
#include <PocoJSONReducingOutputMessageConvertor.h>

using namespace HCE::reduce;
using namespace HCE::reduce_types;
using namespace HCE::reduce_convertors;
using namespace HCE::sphinx;
using namespace HCE::sphinx::reduce_task;
using namespace Poco;
using namespace std;

class Processor{
  public:
    Processor()
    {
      // wrap in builder
      SphinxTaskReducersManagerBuilder<> sphinxTaskReducersManagerBuilder;
      SharedPtr<ReducingPartsCountersStorage> reducingPartsCountersStorage(new ReducingPartsCountersStorage());  
      SharedPtr<SphinxTaskReducersManagerIf<SphinxReduceJobBuilder<> > >sphinxTaskReducersManager = 
                                                           sphinxTaskReducersManagerBuilder.build();
      SharedPtr<ReducingExceptionsTranslator>reducingExceptionsTranslator(new ReducingExceptionsTranslator());
      SharedPtr<ReducingOutputMessageBuilder>reducingOutputMessageBuilder(new ReducingOutputMessageBuilder(reducingExceptionsTranslator));  
      SharedPtr<SupportNotifierIf> supportNotifier(new ConsoleSupportNotifier());
      
      reducingHandler.assign(new ReducingHandler<>(reducingPartsCountersStorage, sphinxTaskReducersManager,
                                                   reducingOutputMessageBuilder, supportNotifier));
    }
    
    std::string process(std::string& json_reducing_input_message, int itemId)
    {
      //may be class members
      PocoJSONReducingInputMessageConvertor pocoJSONReducingInputMessageConvertor;
      PocoJSONReducingOutputMessageConvertor pocoJSONReducingOutputMessageConvertor;
      
      SharedPtr<ReducingInputMessage>reducingInputMessage;
      SharedPtr<ReducingOutputMessage> reducingOutputMessage;
      std::string json_reducing_output_message = "";
      
      int nodesCount = 3; // may be parameters

      try{
        reducingInputMessage = pocoJSONReducingInputMessageConvertor.convertToReducingInputMessageFrom(json_reducing_input_message);
      }
      catch(WrongJSONStructureException& e){
        std::string ret_string = "some error in json struct";
        return ret_string;
      }
      
      reducingHandler->accumulateReducingData(itemId, reducingInputMessage);
      
      try{
        if(reducingHandler->getAccumulateReducingPartsNumberBy(itemId) == nodesCount){
          reducingOutputMessage = reducingHandler->makeReducing(itemId);
          reducingHandler->deleteReducingTaskBy(itemId);
        }
      }
      catch(NotFoundByKeyException& e){
        std::string ret_string = "some logic error";
        return ret_string;
      }
      
     try{
      json_reducing_output_message = pocoJSONReducingOutputMessageConvertor.convertToJSONFrom(reducingOutputMessage);      
     }
     catch(WrongJSONStructureException& e){
       std::string ret_string = "some error in json struct";
       return ret_string;
     }
     return json_reducing_output_message;
   }

  private:
    SharedPtr<ReducingHandler<> >reducingHandler;
};


//work only with c++ objects
class ProcessorWithObjects{
  public:
    ProcessorWithObjects()
    {
      // wrap in builder
      SphinxTaskReducersManagerBuilder<> sphinxTaskReducersManagerBuilder;
      SharedPtr<ReducingPartsCountersStorage> reducingPartsCountersStorage(new ReducingPartsCountersStorage());  
      SharedPtr<SphinxTaskReducersManagerIf<SphinxReduceJobBuilder<> > >sphinxTaskReducersManager = 
                                                           sphinxTaskReducersManagerBuilder.build();
      SharedPtr<ReducingExceptionsTranslator>reducingExceptionsTranslator(new ReducingExceptionsTranslator());
      SharedPtr<ReducingOutputMessageBuilder>reducingOutputMessageBuilder(new ReducingOutputMessageBuilder(reducingExceptionsTranslator));  
      SharedPtr<SupportNotifierIf> supportNotifier(new ConsoleSupportNotifier());
      
      reducingHandler.assign(new ReducingHandler<>(reducingPartsCountersStorage, sphinxTaskReducersManager,
                                                   reducingOutputMessageBuilder, supportNotifier));
    }

    // throws NotFoundByKeyException
    Poco::SharedPtr<ReducingOutputMessage> process(Poco::SharedPtr<ReducingInputMessage>& reducingInputMessage, int itemId)
    {
      
      int nodesCount = 3; // may be parameters      
      SharedPtr<ReducingOutputMessage> reducingOutputMessage;
      
      reducingHandler->accumulateReducingData(itemId, reducingInputMessage);
      if(reducingHandler->getAccumulateReducingPartsNumberBy(itemId) == nodesCount){
        reducingOutputMessage = reducingHandler->makeReducing(itemId);
        reducingHandler->deleteReducingTaskBy(itemId);
      }
      return reducingOutputMessage;      
    }

  private:
    SharedPtr<ReducingHandler<> >reducingHandler;
};



int main(int argc, char** argv)
{
  Processor processor;
  
  std::string json_sphinx_result_with_type = "";
  int itemId = 3;
  
  std::string reducingResult = processor.process(json_sphinx_result_with_type, itemId);
  
  std::cout << reducingResult << endl;
  
  //
  ProcessorWithObjects processorWithObjects;
  Poco::SharedPtr<HCE::reduce_types::ReducingInputMessage>reducingInputMessage;
  
  try{    
    Poco::SharedPtr<HCE::reduce_types::ReducingOutputMessage> reducingOutputMessage =  processorWithObjects.process(reducingInputMessage, itemId);
    // ...
  }
  catch(NotFoundByKeyException& e){
    std::cout << e.what() <<  std::endl;
    return 1;
  }
  
  return 0;
}