static public void main(String[] args) {         
        PairwiseComparison comparison = new PairwiseComparison();
        comparison.setId(UUID.randomUUID().toString());
        comparison.setFirstDataset(new File("data/test1.txt"));
        comparison.setSecondDataset(new File("data/test2.txt"));
        comparison.setAdapterId(TextAdapter.class.getName());
        comparison.setExtractorId(TextHistogramExtractor.class.getName());
        comparison.setMeasureId(LabelHistogramEuclidianDistanceMeasure.class.getName());

        ExecutionEngine ee = new ExecutionEngine(); 
        ee.submit(comparison, new ComparisonStatusHandler() {
            @Override
            public void onStarted() {
                System.out.println("STARTED : ");
            }

            @Override
            public void onFailed(String msg, Throwable e) {
                System.out.println("FAILED  : " + msg);
                e.printStackTrace();
                System.exit(0);
            }

            @Override
            public void onDone(double value) {
                System.out.println("DONE    : " + value);
                System.exit(0

public class TextAdapter implements FileLoader, HasText {
    private File       
  EntityUtils.consume(fileEntity); file;
    private List<String> words;

   
 public log.info("Download complete. Initiating word count generation");
  
  File textFile = processFile(tempFile, receivedMsg.getId());  
  return textFile;       
}

private File processFile(File tempFile, String originalFileId) throws Exception  {
    
    Runtime r = Runtime.getRuntime();
    Process p;     // Process tracks one external native process
      
    String tempDir = System.getProperty("java.io.tmpdir");
    if (new Character(tempDir.charAt(tempDir.length()-1)).toString().equals(System.getProperty("file.separator")) == false){TextAdapter() {}

    // ----------------------------------------------------------------------
    // FileLoader
    // ----------------------------------------------------------------------
    @Override
    public void load(File file) {
        this.file = file;
    }

    @Override
    public String getName() {
        return "Text Document";
    }

    @Override
    public List<String> getSupportedMediaTypes() {
        List<String> mediaTypes = new ArrayList<String>();
      tempDir = tempDir + System.getProperty("file.separatormediaTypes.add("text/*");
    }
    return  mediaTypes;
    String}

 processCmd = "";
 //   String operSystem = System.getProperty("os.name").toLowerCase();

	// TODO: windows impl
    if(operSystem.indexOf("nix") >= 0 || operSystem.indexOf("nux") >= 0 || operSystem.indexOf("aix") > 0 ){
      "wc -w " + tempDir +  tempFile.getName();
    }  ----------------------------------------------------------------------
    // HasText
    // ----------------------------------------------------------------------
    @Override
    public List<String> getWords() {
        if (words == null) {
      
    p = r.exec(processCmd, null, words = new FileArrayList<String>(tempDir));
       StreamGobbler outputGobbler = new StreamGobbler(p.getInputStream(), "INFO", log);
 try {
        StreamGobbler errorGobbler = new StreamGobbler(p.getErrorStream(),"ERROR", log);
    outputGobbler.start();
    errorGobbler.start()BufferedReader br = new BufferedReader(new FileReader(file));
    p.waitFor()            String line;
      
    File outFile = new File(tempDir + tempFile.getName().substring(0, tempFile.getName().lastIndexOf(".")) + ".txt");while((line = br.readLine()) != null) {
    tempFile.delete();
    if(!Files.exists(outFile.toPath()))
      throw new Exception("File not processed correctly. FileString[] isw possibly= corruptline.split(" ");
           
  return outFile;
      
}

public class TextHistogramExtractor implements Extractor
{
    @Override
    public Adapter newAdapter() {
        throw (new RuntimeException("Not supported."));
    }

    @Override
    public String getName() {to RabbitMQ
      *  @param  size        size of the buffer
      */
     virtual void onData(AMQP::Connection *connection, const char *data, size_t size)
     {
   return "Text Histogram Extractor";
   // @todo }

    @Override
    public //Set<Class<? extends AddAdapter>> your own implementation, for example by doing a call to the
         //  send() system call. But be aware that the send() call may not
supportedAdapters() {
        Set<Class<? extends Adapter>> adapters = new HashSet<Class<? extends Adapter>>();
        adapters.add(HasText.class);
        return adapters;
   // }

 send all data at@Override
 once, so you alsopublic needClass<? toextends takeDescriptor> care of bufferinggetFeatureType() {
         //return LabelHistogramDescriptor.class;
  the bytes that}

 could not immediately be@Override
 sent, and try topublic sendDescriptor 
extract(Adapter adapter) throws Exception {
     //  them againif when(adapter theinstanceof socketHasText) becomes{
 writable again
     }

     LabelHistogramDescriptor /**
desc = new LabelHistogramDescriptor();

   *  Method that is called by the AMQP for library(String whenword the login attempt : ((HasText) adapter).getWords()) {
      *  succeeded. After this method has been called, the connection is ready 
 desc.increaseBin(word);
         *  to use.}

      *  @param  connection  return desc;
    The connection that can now} beelse used{
      */
      virtualthrow voidnew onConnectedUnsupportedTypeException(Connection *connection);
      {
  }
    }
   // @todo
    @Override
    public //  add your own implementation, for example by creating a channel boolean hasPreview(){
        return false;
         //  instance, and start publishing or consuming}
    
      }
@Override
    public  /**String previewName(){
      *  Methodreturn thatnull;
 is called  }
}

public class LabelHistogramEuclidianDistanceMeasure implements Measure 
{by the AMQP library when a fatal error occurs
    @Override
  *  onpublic the connection, for example because data received from RabbitMQ
SimilarityPercentage normalize(Similarity similarity) {
        return new SimilarityPercentage(1 *  could not be recognized.- similarity.getValue());
    }

    @Override
  *  @parampublic String connectiongetFeatureType() {
     The connection on which the error occured
  return LabelHistogramDescriptor.class.getName();
    }

    *@Override
  @param  messagepublic String getName() {
      A human readablereturn error message"Histogram Distance";
    }

  */
  @Override
    virtualpublic voidClass<LabelHistogramEuclidianDistanceMeasure> onErrorgetType(Connection *connection, const std::string &message)
) {
        return {LabelHistogramEuclidianDistanceMeasure.class;
    }

    // @todocorrelation

    @Override
    //public Similarity add your own implementationcompare(Descriptor desc1, forDescriptor exampledesc2) bythrows reportingException the error{
        //if ((desc1 toinstanceof theLabelHistogramDescriptor) user&& of(desc2 your program, log the error, and destruct the 
instanceof LabelHistogramDescriptor)) {
            LabelHistogramDescriptor lhd1 //=  connection object because it is no longer in a usable state
(LabelHistogramDescriptor) desc1;
            LabelHistogramDescriptor lhd2 }
= (LabelHistogramDescriptor) }desc2;

}

namespace CPPExample {

  /**
   *  Parse data that was// receviedget fromall RabbitMQpossible labels
   *   
   *  Every timeSet<String> thatlabels data= comes in from RabbitMQ, you should call this method to parse
   *  the incoming data, and let it handle by the AMQP-CPP library. This method returns the number
   *  of bytes that were processed.
   *
   *  If not all bytes could be processed because it only contained a partial frame, you should
   *  call this same method later on when more data is available. The AMQP-CPP library does not do
   *  any buffering, so it is up to the caller to ensure that the old data is also passed in that
   *  later call.
   *
   *  @param  buffer      buffer to decode
   *  @param  sizenew HashSet<String>();
            labels.addAll(lhd1.getLabels());
            labels.addAll(lhd2.getLabels());

            // normalize
            lhd1.normalize();
            lhd2.normalize();
            
            // compute distance
            double sum = 0;

            for (String s : labels) {
                Double b1 = lhd1.getBin(s);
               size ofDouble theb2 buffer to decode= lhd2.getBin(s);
   *  @return        
     number of bytes that were processed
   */
  size_t if parse(char *buffer, size_t size)b1 == null) {
  {
     return _implementation.parse(buffer, size);
  }
}