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 : "

protected void processMessageReceived() {
  try {
    try {
      ExampleJavaExtractorService extrServ = new ExampleJavaExtractorService(this);
      jobReceived = getRepresentation(messageReceived, ExtractionJob.class);   }

     
    
   @Override
           File textFilepublic =void extrServ.processJob(jobReceived);
onFailed(String msg, Throwable e) {
          
      jobReceivedSystem.out.setFlagprintln("wasText"FAILED  : " + msg);

      log.info("Word count extraction complete. Returning word count file as intermediate resulte."printStackTrace();
             sendStatus(jobReceived.getId(), this.getClass().getSimpleName(), "Word count extraction complete. Returning word count file as intermediate result.", log);   System.exit(0);
            }

            @Override
        
    public void uploadIntermediateonDone(textFile, "text/plain", log);double value) {
        
        textFileSystem.out.delete(println("DONE    : " + value);
        
        sendStatus(jobReceivedSystem.getId(), this.getClass().getSimpleName(), "DONE.", log);
exit(0);
    } catch (Exception ioe) {
    }

  log.error("Could not finish extraction job.", ioe);
      sendStatus(jobReceived.getId(), this.getClass().getSimpleName(), "Could not finish extraction job.", log);
@Override
            public void sendStatus(jobReceived.getId(), this.getClass().getSimpleName(), "DONE.", log);
onAborted(String msg) {
     }
  } catch(Exception e) {
      eSystem.out.printStackTrace(println("ABORTED : " + msg);
                System.exit(10);
  } 
}

public File processJob(ExtractionJob receivedMsg) throws Exception{
      }
  log.info("Downloading text file with ID "+ receivedMsg.getIntermediateId() +" from " + receivedMsg.getHost());
  callingExtractor.sendStatus(receivedMsg.getId(), callingExtractor.getClass().getSimpleName(), "Downloading text file.", log);
      
  DefaultHttpClient httpclient = new DefaultHttpClient();
  HttpGet httpGet = new HttpGet(receivedMsg.getHost() +"api/files/"+ receivedMsg.getIntermediateId()+"?key="+playserverKey);    
  HttpResponse fileResponse = httpclient.execute(httpGet);
  log.info(fileResponse.getStatusLine());
  if(fileResponse.getStatusLine().toString().indexOf("200") == -1){
    throw new IOException("File not found.");
  }
  HttpEntity fileEntity = fileResponse.getEntity();
  InputStream fileIs = fileEntity.getContent();
  
  Header[] hdrs = fileResponse.getHeaders("content-disposition");
  String contentDisp = hdrs[0].toString();
  
  String fileName = contentDisp.substring(contentDisp.indexOf("filename=")+9);
  File tempFile = File.createTempFile(fileName.substring(0, fileName.lastIndexOf(".")),      fileName.substring(fileName.lastIndexOf(".")).toLowerCase());
  OutputStream fileOs = new FileOutputStream(tempFile);   
  IOUtils.copy(fileIs,fileOs);
  fileIs.close();
  fileOs.close });
    }

public class TextAdapter implements FileLoader, HasText {
    private File         file;
    private List<String> words;

    public 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>();
      
  EntityUtilsmediaTypes.consume(fileEntityadd("text/*");
  
      return mediaTypes;
  
  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}

    // ----------------------------------------------------------------------
    // HasText
    // ----------------------------------------------------------------------
    @Override
    public List<String> getWords() {
        if (words == null) {
            words = new ArrayList<String>();
    Process    p;    try //{
 Process tracks one external native process
      
    StringBufferedReader tempDirbr = System.getProperty("java.io.tmpdir"new BufferedReader(new FileReader(file));
    if (new Character(tempDir.charAt(tempDir.length()-1)).toString().equals(System.getProperty("file.separator")) == false){
      tempDir = tempDir + System.getProperty("file.separator")String line;
    }
       
    String processCmdwhile((line = "";
    String operSystem = System.getProperty("os.name").toLowerCase();

	// TODO: windows impl
    if(operSystem.indexOf("nix") >= 0 || operSystem.indexOf("nux") >= 0 || operSystem.indexOf("aix") > 0 ){
br.readLine()) != null) {
                    String[] w = line.split(" ");
             "wc -w " + tempDir +  tempFile.getName();
words.addAll(Arrays.asList(w));
      }    
      }
    p = r.exec(processCmd, null, new File(tempDir));
    StreamGobbler outputGobbler = new StreamGobbler(pbr.getInputStream(), "INFO", logclose();
    StreamGobbler  errorGobbler = new StreamGobbler(p.getErrorStream(),"ERROR", log);
  } catch outputGobbler.start(IOException e); {
    errorGobbler.start();
    p.waitFor();
        e.printStackTrace();
    File outFile = new File(tempDir + tempFile.getName().substring(0, tempFile.getName().lastIndexOf(".")) + ".txt"); }
    tempFile.delete();
    if(!Files.exists(outFile.toPath()))}
      throw new Exception("File not processed correctly. File is possibly corrupt.");
      
  return outFile;
      
}

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

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

    @Override
    public Set<Class<? extends Adapter>> supportedAdapters() {
        Set<Class<? extends Adapter>> adapters = new HashSet<Class<? extends Adapter>>();

public class LabelHistogramEuclidianDistanceMeasure implements Measure 
{
    @Override
    public SimilarityPercentage *normalize(Similarity similarity) @param{
  connection      Thereturn connectionnew thatSimilarityPercentage(1 can now be used
  - similarity.getValue());
    }

    */@Override
    public String virtual void onConnected(Connection *connection)getFeatureType() {
      {
  return LabelHistogramDescriptor.class.getName();
    }

   // @todo@Override
    public String getName() {
  //  add your own implementation, forreturn example by creating a channel "Histogram Distance";
    }

    @Override
     //public Class<LabelHistogramEuclidianDistanceMeasure> getType() {
  instance, and start publishing or consuming
 return LabelHistogramEuclidianDistanceMeasure.class;
    }

      /**// correlation

    @Override
  *  Methodpublic thatSimilarity is called by the AMQP library when a fatal error occurs
compare(Descriptor desc1, Descriptor desc2) throws Exception {
        if ((desc1 *instanceof LabelHistogramDescriptor) on&& the(desc2 connection, for example because data received from RabbitMQ
instanceof LabelHistogramDescriptor)) {
           * LabelHistogramDescriptor couldlhd1 not= be recognized.(LabelHistogramDescriptor) desc1;
      *  @param  connection  LabelHistogramDescriptor lhd2 =  The connection on which the error occured
(LabelHistogramDescriptor) desc2;

            *// get @paramall possible messagelabels
         A human readable errorSet<String> message
labels = new HashSet<String>();
   */
      virtual void onError(Connection *connection, const std::string &message) labels.addAll(lhd1.getLabels());
      {
      labels.addAll(lhd2.getLabels());

   // @todo
        // normalize
 add your own implementation, for example by reporting the error
  lhd1.normalize();
      //  to the user of your program, log the error, and destruct the 
 lhd2.normalize();
            
    //  connection object because it is no longer in a usable state
// compute distance
         }
  };

}

namespace CPPExample {

  /** double sum = 0;

   *  Parse data that was recevied from RabbitMQ
 for (String s *: labels) {
   *  Every time that data comes in from RabbitMQ, you should call thisDouble methodb1 to parse= lhd1.getBin(s);
   *  the incoming data, and let it handle by the AMQP-CPP library. ThisDouble methodb2 returns the number
= lhd2.getBin(s);
    *  of bytes that were processed.
   *
   *  If not all bytes could be processed because it only contained a if partial frame, you should(b1 == null) {
   *  call this same method later on when more data is available. The AMQP-CPP library does notsum do
+= b2 * b2;
 *  any buffering, so it is up to the caller to ensure that the old} dataelse isif also(b2 passed== innull) that{
   *  later call.
   *
   *  @param  buffer    sum += bufferb1 to* decodeb1;
   *  @param  size        size of} the buffer to decodeelse {
   *  @return             number of bytessum that+= were(b1 processed
- b2)  */
 (b1 size_t parse(char *buffer, size_t size)
  {- b2);
     return _implementation.parse(buffer, size);
  }
}