gt: 		return super.getDoubleList(path, defaultValue);
context: package me.asofold.bpl.simplyvanish.config.compatlayer;
  
  import java.io.File;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import org.bukkit.configuration.Configuration;
  import org.bukkit.configuration.ConfigurationOptions;
  import org.bukkit.configuration.ConfigurationSection;
  import org.bukkit.configuration.MemoryConfiguration;
  
  public abstract class AbstractNewConfig extends AbstractConfig {
  	File file = null;
  	MemoryConfiguration config = null;
  	
  	public AbstractNewConfig(File file){
  		setFile(file);
  	}
  	
  	public void setFile(File file) {
  		this.file = file;
  		this.config = new MemoryConfiguration();
  		setOptions(config);
  	}
  
  	@Override
  	public boolean hasEntry(String path) {
  		return config.contains(path) || (config.get(path) != null);
  	}
  	
  	
  
  
  	@Override
  	public String getString(String path, String defaultValue) {
  		if (!hasEntry(path)) return defaultValue;
  		return config.getString(path, defaultValue);
  	}
  
  	
  
  	@Override
  	public List<String> getStringKeys(String path) {
  		// TODO policy: only strings or all keys as strings ?
  		List<String> out = new LinkedList<String>();
  		List<Object> keys = getKeys(path);
  		if ( keys == null ) return out;
  		for ( Object obj : keys){
  			if ( obj instanceof String ) out.add((String) obj);
  			else{
  				try{
  					out.add(obj.toString());
  				} catch ( Throwable t){
  					// ignore.
  				}
  			}
  		}
  		return out;
  	}
  
  	@Override
  	public List<Object> getKeys(String path) {
  		List<Object> out = new LinkedList<Object>();
  		Set<String> keys;
  		if ( path == null) keys = config.getKeys(false);
  		else{
  			ConfigurationSection sec = config.getConfigurationSection(path);
  			if (sec == null) return out;
  			keys = sec.getKeys(false);
  		}
  		if ( keys == null) return out;
  		out.addAll(keys);
  		return out;
  	}
  	
  	@Override
  	public List<Object> getKeys() {
  		return getKeys(null);
  	}
  
  	@Override
  	public Object getProperty(String path, Object defaultValue) {
  		Object obj = config.get(path);
  		if ( obj  == null ) return defaultValue;
  		else return obj;
  	}
  
  	@Override
  	public List<String> getStringKeys() {
  		return getStringKeys(null);
  	}
  
  	@Override
  	public void setProperty(String path, Object obj) {
  		config.set(path, obj);
  	}
  
  	@Override
  	public List<String> getStringList(String path, List<String> defaultValue) {
  		if ( !hasEntry(path)) return defaultValue;
  		List<String> out = new LinkedList<String>();
  		List<String> entries = config.getStringList(path);
  		if ( entries == null ) return defaultValue;
  		for ( String entry : entries){
  			if ( entry instanceof String) out.add(entry);
  			else{
  				try{
  					out.add(entry.toString());
  				} catch (Throwable t){
  					// ignore
  				}
  			}
  		}
  		return out;
  	}
  
  	@Override
  	public void removeProperty(String path) {
  		if (path.startsWith(".")) path = path.substring(1);
  		// VERY EXPENSIVE
  		MemoryConfiguration temp = new MemoryConfiguration();
  		setOptions(temp);
  		Map<String, Object> values = config.getValues(true);
  		if (values.containsKey(path)) values.remove(path);
  		else{
  			final String altPath = "."+path;
  			if (values.containsKey(altPath)) values.remove(altPath);
  		}
  		for ( String _p : values.keySet()){
  			Object v = values.get(_p);
  			if (v == null) continue;
  			else if (v instanceof ConfigurationSection) continue;
  			String p;
  			if (_p.startsWith(".")) p = _p.substring(1);
  			else p = _p;
  			if (p.startsWith(path)) continue;
  			temp.set(p, v);
  		}
  		config = temp;
  	}
  
  
  	@Override
  	public Boolean getBoolean(String path, Boolean defaultValue) {
  		if (!config.contains(path)) return defaultValue;
  		String val = config.getString(path, null);
  		if (val != null){
  			if (val.equalsIgnoreCase("true")) return true;
  			else if (val.equalsIgnoreCase("false")) return false;
  			else return defaultValue;
  		}
  		Boolean res = defaultValue; 
  		if ( val == null ){
  			if ( defaultValue == null) defaultValue = false;
  			res = config.getBoolean(path, defaultValue);
  		}
  		return res;
  	}
  
  
  
  
  	@Override
  	public Double getDouble(String path, Double defaultValue) {
  		if (!config.contains(path)) return defaultValue;
  		Double res = super.getDouble(path, null);
  		if ( res == null ) res = config.getDouble(path, ConfigUtil.canaryDouble);
  		if ( res == ConfigUtil.canaryDouble) return defaultValue;
  		return res;
  	}
  
  
  
  
  	@Override
  	public Long getLong(String path, Long defaultValue) {
  		if (!config.contains(path)) return defaultValue;
  		Long res = super.getLong(path, null);
  		if ( res == null ) res = config.getLong(path, ConfigUtil.canaryLong);
  		if ( res == ConfigUtil.canaryLong) return defaultValue;
  		return res;
  	}
  
  
  
  
  	@Override
  	public Integer getInt(String path, Integer defaultValue) {
  		if (!config.contains(path)) return defaultValue;
  		Integer res = super.getInt(path, null);
  		if ( res == null ) res = config.getInt(path, ConfigUtil.canaryInt);
  		if ( res == ConfigUtil.canaryInt) return defaultValue;
  		return res;
  	}
  
  
  
  
  	@Override
  	public List<Integer> getIntList(String path, List<Integer> defaultValue) {
  		// TODO Auto-generated method stub
  		return super.getIntList(path, defaultValue);
  	}
  
  
  
  
  	@Override
  	public List<Double> getDoubleList(String path, List<Double> defaultValue) {
  		// TODO Auto-generated method stub
  