modepropertyconfiguration.java

AStar算法

/*******************************************************************************
 * Copyright © 2008 Sandro Badame. All Rights Reserved.
 * 
 * This software and the accompanying materials is available under the 
 * Eclipse Public License 1.0 (EPL), which accompanies this distribution, and is
 * available at http://visualjpf.sourceforge.net/epl-v10.html
 ******************************************************************************/
package com.javapathfinder.vjp.config.editors;

import gov.nasa.jpf.Config;
import gov.nasa.jpf.JPF;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jdt.core.IJavaProject;

import com.javapathfinder.vjp.DefaultProperties;
import com.javapathfinder.vjp.VJP;
/**
 * This class serves to manage the userdefined and default properties for JPF.
 * There are three levels of properties:
 * <ul>
 * <li>JPF default - a static set of properties loaded from jpf.properties and default.properties
 * <li>VJP default - properties determined by VJP (Overrides some properties from JPF default)
 * <li>User defined - properties determined by the user (Overrides the properties defined in VJP or JPF default)
 * </ul>
 * 
 * Each of these levels is represented by a map that contains the name/value pair
 * of their respective properties. When a property is to be retrieved this class
 * first looks to the user defined layer, then to the VJP layer and then finally
 * to the JPF layer. Values defined by the user should only be defined on the 
 * user defined layer. 
 * Only the user defined layer is saved to the Mode Property Configuration File.
 * 
 * @author Sandro Badame
 */
public class ModePropertyConfiguration{

  
  /**
   * the default properties according to jpf.defaults
   */ 
  private static HashMap<String, String> jpfDefined;
  
  /**
   * contains default properties as determined by VJP by this project.
   */
  private HashMap<String, String> vjpDefined;
  
  /**
   * contains the custom user defined values
   */
  private HashMap<String, String> userDefined = new HashMap<String, String>();
    
  /**
   * This is set true when there are changes to be made to the property file.
   */
  private boolean isDirty = false;
  
  /**
   * The file that this ModePropertyConfiguration refers to.
   */
  private IFile file;
  
  /**
   * Hangs onto any listeners that this may have
   */
  private ArrayList<PropertyChangeListener> listeners = new ArrayList<PropertyChangeListener>(3);
   
  /**
   * Creates a default instance of the PropertyManager. Loads values from 
   * file "jpf.properties", then loads values from the config file specified.
   * 
   * @param configFile the file that properties and loaded from and stored to.
   * @param project the project used to determine the VJP properties
   */
  public ModePropertyConfiguration(IFile configFile, IJavaProject project) {
    this.file = configFile;
    checkJPFDefaults();
    setVJPDefaults(project);
    parseConfigFile();   
  }
  
  /**
   * checks to see if the JPF defaults have been loaded.
   * If not, they are.
   */
  @SuppressWarnings("unchecked")
  private static void checkJPFDefaults() {
    if (jpfDefined != null)
      return;
    jpfDefined = new HashMap<String, String>();
    Config config = new Config(null, "jpf.properties", "", JPF.class);
    Enumeration<String> numer = (Enumeration<String>) config.propertyNames();
    while (numer.hasMoreElements()) {
      String key = numer.nextElement();
      jpfDefined.put(key, config.getProperty(key));
    }
  }
  
  /**
   * Sets the VJP default properties for this configuration based on the the
   * project given.
   * 
   * @param project The project to be used to define the VJP default settings
   */
  public void setVJPDefaults(IJavaProject project){
    vjpDefined = DefaultProperties.getDefaultProperties(project);
  }
  
  /**
   * Clears all of the config properties contained and then reloads all 
   * properties from the configuration file.
   * NOTE: this does not reload from jpf.properties or default.properties
   * 
   * @throws IOException if the file can not be read
   * @throws CoreException if the file can not be found
   */
  public void reloadFromFile() throws IOException, CoreException{
    vjpDefined.clear();
    userDefined.clear();
    parseConfigFile();
  }
  
  /**
   * Parses the configuration file and handles it appropriatly
   *
   */
  public void parseConfigFile(){
    HashMap<String, String> h = getConfigFileProperties(file);
    for(String key : h.keySet()){
      handleProperty(key, h.get(key));
    }
  }

  /**
   * Loads this configuration with the properties contained in configuration
   * file associated.
   * @throws IOException
   * @throws CoreException
   * @return the HashMap that contains all of the properties loaded from 
   *         jpf.properties and default.properties
   */
  public static HashMap<String, String> getConfigFileProperties(IFile file){
   HashMap<String, String> h = new HashMap<String, String>();
   BufferedReader reader;
   String line;
   
   try{
     reader = new BufferedReader(new InputStreamReader(file.getContents()));
   }catch(CoreException ce){
     VJP.logError("Input Stream from config file could not be opened.", ce);
     return h;
   }
   
   try{  
     while ((line = reader.readLine()) != null) {
       line = line.trim();
       if (line.equals("") || line.charAt(0) == '#')
         continue;
       int index = line.indexOf('=');
       if (index != -1){
         String name = line.substring(0, index).trim();
         String value = line.substring(index+1, line.length()).trim();
         h.put(name, value);
       }
     }
   }catch(IOException ioe){
     VJP.logError("Could not read line from config file", ioe);
   }
   try{
     if (reader !=  null)reader.close();
   }catch(IOException ioe){
     VJP.logError("Could not close InputStream.", ioe);
   }
   return h;
  }
  
  /*
   * Decides where a property that has been loaded from a file belongs.
   */
  private void handleProperty(String name, String value){
    if (!(vjpDefined.containsKey(name) && vjpDefined.get(name).equals(value)))
     userDefined.put(name, value);
  }
  
  /**
   * Saves the properties stored in this configuration to the corresponding
   * file.
   */
  public void save() throws IOException, CoreException{
    save(new NullProgressMonitor());
  }
  
  /**
   * Saves the properties stored in this configuration to the corresponding
   * file. Progress can be logged on the monitor passed.
   * 
   * @param monitor used to track the progress of saving the file
   */
  public void save(IProgressMonitor monitor) throws IOException, CoreException{
    monitor.beginTask("Saving Configuration File", 3);
    
    monitor.subTask("Reading Configuration File...");
    ArrayList<ConfigLine> contents = getFileContents(file);
    ArrayList<String> properties = new ArrayList<String>(userDefined.keySet());
    monitor.worked(1);
    
    monitor.subTask("Opening data streams...");
    PipedInputStream fileData = new PipedInputStream();
    PipedOutputStream propertyData = new PipedOutputStream(fileData);
    PrintStream writer = new PrintStream(propertyData);
    monitor.worked(1);
    
    monitor.subTask("Writing to file...");
    for(ConfigLine c : contents){
      writer.println(c.getLine());
      if (c instanceof PropertyLine)
        properties.remove(((PropertyLine)c).getPropertyName());
    }

    for(String p : properties){
      writer.println(p+"="+getPropertyValue(p));
    }

    writer.flush();
    writer.close();
    file.setContents(fileData, true, true, new SubProgressMonitor(monitor,1));
    fileData.close();
    setDirty(false);
    monitor.done();
  }
  
  private ArrayList<ConfigLine> getFileContents(IFile file) throws CoreException, IOException{
    ArrayList<ConfigLine> c = new ArrayList<ConfigLine>();
    BufferedReader reader = new BufferedReader(new InputStreamReader(file.getContents()));

    String s;
    while((s = reader.readLine()) != null){
      if (isPropertyLine(s)){
        s = s.trim();
        PropertyLine p = new PropertyLine(s.substring(0, s.indexOf('=')));
        c.add(p);
      }else{
        c.add(new ConfigLine(s));
      }
    }
    reader.close();
    return c;
  }
  
  private static boolean isPropertyLine(String line){
    String s = line.trim();
    return !(s.equals("") || s.charAt(0) == '#');
  }
  
  /**
   * Move the property file.
   * @param newPath the path representing the new location of the configuration file
   * @param monitor tracks the progress of moving the file to the new location
   */
  public void movePropertiesFile(IPath newPath, IProgressMonitor monitor) throws CoreException{