Interpreter.java

Go to the documentation of this file.

package myShell;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

import myDataBases.MediaBase;

import org.jdom.*;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;



public class Interpreter {

      00037       // Fields
      00039 
      private MediaBase mediaBase;
      private Integer numberOfMedia;

  
      00051       // Constructors
      00053 
      public Interpreter (MediaBase database)
      {
            // media
            this.mediaBase = database;
            this.numberOfMedia = 0;
            for (Integer[] array : this.mediaBase.getAllMedia())
                  this.numberOfMedia += array.length;
      }
  
      00072       // Methods
      00074 


// ============================== SETTINGS =========================================


      public static Map <String,String> getConfig()
      {
            Element rootConfig;
            org.jdom.Document documentConfig;
          Map <String,String> conf = new Hashtable <String,String>() ;
            SAXBuilder sxb = new SAXBuilder();
            try
            {
                  documentConfig= sxb.build(new File("../data/config.xml"));
                rootConfig = documentConfig.getRootElement();
                Element constants = rootConfig.getChild("constants");
                  Iterator it = constants.getChildren().iterator();
                  while (it.hasNext())
                  {
                        Element current = (Element)it.next();
                        conf.put(current.getName(), current.getValue());
                  }
            }
          catch(Exception e){ e.printStackTrace(); }
            return conf ;
      }
  
  
      public static List<String> getAxes()
      {

            Element rootConfig;
            org.jdom.Document documentConfig;
            SAXBuilder sxb = new SAXBuilder();
            List<String> listAxes = new ArrayList <String>() ;
            try
            {
                  documentConfig= sxb.build(new File("../data/config.xml"));
                  rootConfig = documentConfig.getRootElement();
                  Element axes = rootConfig.getChild("axes");
                  if (axes != null)
                  {
                        Iterator it = axes.getChildren().iterator();
                        while (it.hasNext())
                        {
                              Element current = (Element)it.next();
                              listAxes.add(current.getValue());
                        }
                  }
                  else
                        listAxes = null;
            }
            catch(Exception e){ e.printStackTrace(); }
            return listAxes;
      }




      public static List<String> getFields(String fields)
      {
            Element rootConfig;
            org.jdom.Document documentConfig;
            List<String> listFields = new ArrayList <String>() ;
            if ( (fields.equals("SQLfield")) || (fields.equals("SQLtype")) || (fields.equals("CSVfield")) )
            {
                  SAXBuilder sxb = new SAXBuilder();
                  try
                  {
                        documentConfig= sxb.build(new File("../data/config.xml"));
                        rootConfig = documentConfig.getRootElement();
                        Element HDfields = rootConfig.getChild("hardDataFields");
                        Iterator it = HDfields.getChildren().iterator();
                        while (it.hasNext())
                        {
                              Element current = (Element)it.next();
                              String entry = current.getChild(fields).getValue() ;
                              if (entry.length() > 1)
                                    listFields.add(entry);
                        }
                  }
                  catch(Exception e){ e.printStackTrace(); }
            }
            else
                  listFields = null;
            return listFields;
      }


      public static Boolean checkFile(LogWriter log)
      {
            Boolean fine = true;
            log.append("------- Checking config.xml");

            // checking the constants
            Map<String,String> configContent = getConfig() ;
            String[] necessaryConstants = { "mediaPath", "sqlBase", "sqlUser", "antechamberUrl", "cfKey", "cfJobNumber" };
            for (String constant : necessaryConstants)
                  if (configContent.keySet().contains(constant))
                        log.append(constant+" constant found");
                  else
                  {
                        log.append("ERROR : " + constant + " NOT FOUND. Interrupting.");
                        fine = false;
                  }
            
            // checking the presence of axes
            List<String> axes = getAxes() ;
            if (axes == null)
            {
                  fine = false;
                  log.append("ERROR : no axis found. Interrupting.");
            }
            else
                  log.append(axes.size() + " axes found.");
            
            // checking the content of the hard data fields
            List<String> fields = getFields("SQLfield");
            String[] necessaryFields = { "media1", "media2", "greater", "axis" };
            if (fields == null)
                  log.append("ERROR : no 'hardDataFields' section in the config.xml. Interrupting.");
            else
                  for (String field : necessaryFields)
                        if (fields.contains(field))
                              log.append(field +" found in the hardDataFields section");
                        else
                        {
                              log.append("ERROR : " + field + " NOT FOUND in the hardDataFields section. Interrupting.");
                              fine = false;
                        }
            
            log.append("------- END check config.xml\n");
            return fine;
      }



// ============================== PREVIOUS RESULTS =====================================


      public static Integer getLastJob()
      {
            Integer id = 0;
            try{
                  InputStream ips = new FileInputStream("../data/previously/lastJob"); 
                  InputStreamReader ipsr = new InputStreamReader(ips);
                  BufferedReader br = new BufferedReader(ipsr);
                  id = Integer.parseInt(br.readLine());
                  br.close(); 
            }           
            catch (Exception e){ e.printStackTrace(); }
            return id;
      }
      
      
      public static void setLastJob(Integer id)
      {
            try
            {
                  FileWriter fw = new FileWriter("../data/previously/lastJob", false);
                  BufferedWriter output = new BufferedWriter(fw);
                  output.write(id.toString());
                  output.flush();
                  output.close();
            } catch(Exception e) { e.printStackTrace(); }
      }


      private List<Integer[]> parsePrevious(String axis)
      {
            Element rootPrevious;
            org.jdom.Document documentPrevious;
            List<Integer[]> result = new ArrayList<Integer[]>();
            SAXBuilder sxb = new SAXBuilder();
            try
            {
                  documentPrevious = sxb.build(new File("../data/previously/" + axis + ".xml"));
                rootPrevious = documentPrevious.getRootElement();
                  Iterator it = rootPrevious.getChildren().iterator();
                  while (it.hasNext())
                  {
                        Element array = (Element)it.next();
                        List<Integer> arrayContent = new ArrayList<Integer>();
                        Iterator jt = array.getChildren().iterator();
                        while (jt.hasNext())
                        {
                              Element entry = (Element)jt.next();
                              arrayContent.add (Integer.parseInt(entry.getValue()) );
                        }
                        result.add(arrayContent.toArray(new Integer[0]));
                  }
            }
            catch(Exception e){ e.printStackTrace(); }
            
            return result;
      }

      
      public List<Integer[]> getCurrentState(LogWriter log, String axis)
      {
            List<Integer[]> lst;
            File previouslyInCPS = new File("../data/previously/");
            // checking if the file exists.
            Integer count = 0;
            for (String file : previouslyInCPS.list())
                  if (file.equals(axis + ".xml"))
                        break;
                  else
                        count ++;
            if (count == previouslyInCPS.list().length)
            {
                  lst = new ArrayList<Integer[]>();
                  lst = this.mediaBase.getAllMedia();
                  log.append("[DONE] Reading media to sort.\n   ... Note: no previous results found for " + axis +
                              ": starting from the beginning.");
            }
            else
            {
                  lst = parsePrevious(axis);
                  log.append("[DONE] Reading media to sort.\n   ... Note: previous results found for " + axis +
                              ": starting where we left.");
            }
            return lst;
      }



// ============================== SAVING RESULTS =====================================
      
      
      
      public void generateIntermediaryXMLs(String xmlFile, List<Integer[]> content)
      {

            Element rootResults = new Element("results");
            org.jdom.Document documentResults = new Document(rootResults);
            
            Map<Integer, Map<String,String>> mediaCharac= this.mediaBase.getContent();
            Map<String,String> media ;
            Element charac;
            
            for (Integer[] array : content)
            {
                  Element arrayElement = new Element("array");
                  for (Integer mediaID : array)
                  {
                        Element identifier = new Element("id");
                        identifier.setText(String.valueOf(mediaID));
                        arrayElement.addContent(identifier);
                  }
                  rootResults.addContent(arrayElement);
            }
            try
            {
                  XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
                  sortie.output(documentResults, new FileOutputStream(xmlFile));
            }
            catch (Exception e){ e.printStackTrace(); }
      }

        
      private Double rank2value(Integer rank)
      {
            Double value =  ( (2.0*rank)/(this.numberOfMedia-1) ) - 1.0;
            return value;
      }


      private List< Map<String,Integer> > preformating(Map<String,Integer[]> sortResults)
      {
            List< Map<String,Integer> > newMap = new ArrayList< Map<String,Integer> >();
            // loop on the ID of the media considered
            for (int media=0; media<this.numberOfMedia; media++)
            {
                  Map<String,Integer> mediaRanks = new Hashtable<String,Integer>();
                  // loop on the label of the axis considered
                  for ( String axis : sortResults.keySet() )
                  {
                        int rank = 0;
                        // loop to find the rank of the media along the "axis" axis
                        while (rank<sortResults.get(axis).length)
                              if (sortResults.get(axis)[rank] == media)
                                    break;
                              else
                                    rank++ ;
                        mediaRanks.put(axis,rank);
                  }
                  newMap.add(mediaRanks);
            }
            return newMap;
      }


      public String generateFinalXML(String xmlFile, Map<String,Integer[]> sortResults)
      {
            Element rootResults = new Element("results");
            org.jdom.Document documentResults = new Document(rootResults);
            Map<Integer, Map<String,String>> mediaCharac= this.mediaBase.getContent();
            Map<String,String> media ;
            List< Map<String,Integer> > results = this.preformating(sortResults) ;
            Element charac;
            String xmlString = "A problem was encoutered!";
            for (Integer mediaID : mediaCharac.keySet())
            {
                  // retrieving information on this media
                  media = mediaCharac.get(mediaID);
                  // creation of a new node corresponding to a new media
                  Element mediaElement = new Element("media");
                  Attribute identifier = new Attribute("id",String.valueOf(mediaID));
                  mediaElement.setAttribute(identifier);
                  for (String entry : media.keySet())
                  {
                        charac = new Element(entry);
                        charac.setText(media.get(entry));
                        mediaElement.addContent(charac);
                  }
                  // addition of its values along each axis
                  Map<String,Integer> resultsForThisMedia = results.get(mediaID); 
                  for ( Iterator<String> emotion = resultsForThisMedia.keySet().iterator(); emotion.hasNext(); )
                  {
                        String axis = emotion.next();
                        Integer rank = resultsForThisMedia.get(axis);
                        Element coordinate = new Element(axis);
                        coordinate.setText(this.rank2value(rank).toString());
                        mediaElement.addContent(coordinate);
                  }
                  rootResults.addContent(mediaElement);
            }
            // Writing the xml Document in a hard file
            try
            {
                  XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
                  sortie.output(documentResults, new FileOutputStream(xmlFile));
                  xmlString = sortie.outputString(documentResults);
            }
            catch (Exception e){ e.printStackTrace(); }
            return xmlString;
      }

}