| Methods Summary |
|---|
| public void | addListener(COConfigurationListener listener)
try{
this_mon.enter();
listeners.add(listener);
}finally{
this_mon.exit();
}
|
| public void | addParameterListener(java.lang.String parameter, ParameterListener listener)
try{
this_mon.enter();
if(parameter == null || listener == null)
return;
Vector parameterListener = (Vector) parameterListeners.get(parameter);
if(parameterListener == null) {
parameterListeners.put(parameter, parameterListener = new Vector());
}
if(!parameterListener.contains(listener))
parameterListener.add(listener);
}finally{
this_mon.exit();
}
|
| protected static java.lang.String | bytesToString(byte[] bytes)
try{
return( new String( bytes, Constants.DEFAULT_ENCODING ));
}catch( Throwable e ){
return( new String(bytes));
}
|
| public boolean | doesParameterNonDefaultExist(java.lang.String parameter)Does the given parameter exist.
return propertiesMap.containsKey( parameter );
|
| public void | generate(IndentWriter writer)
writer.println( "Configuration Details" );
try{
writer.indent();
writer.println( "System Properties" );
try{
writer.indent();
Properties props = System.getProperties();
Iterator it = new TreeSet( props.keySet()).iterator();
while(it.hasNext()){
String key = (String)it.next();
writer.println( key + "=" + props.get( key ));
}
}finally{
writer.exdent();
}
writer.println( "Azureus Config" );
try{
writer.indent();
Iterator it = new TreeSet(propertiesMap.keySet()).iterator();
while( it.hasNext()){
Object key = it.next();
Object value = propertiesMap.get(key);
boolean bParamExists = ConfigurationDefaults.getInstance().doesParameterDefaultExist(key.toString());
if (!bParamExists)
key = "[NoDef] " + key;
if ( value instanceof Long ){
writer.println( key + "=" + value );
}else if ( value instanceof List ){
writer.println( key + "=" + value + "[list]" );
}else if ( value instanceof Map ){
writer.println( key + "=" + value + "[map]" );
}else if ( value instanceof byte[] ){
byte[] b = (byte[])value;
boolean hex = false;
for (int i=0;i<b.length;i++){
char c = (char)b[i];
if ( ! ( Character.isLetterOrDigit(c) ||
"`¬\"£$%^&*()-_=+[{]};:'@#~,<.>/?'".indexOf(c) != -1 )){
hex = true;
break;
}
}
writer.println( key + "=" + (hex?ByteFormatter.nicePrint(b):bytesToString((byte[])value)));
}else{
writer.println( key + "=" + value + "[unknown]" );
}
}
}finally{
writer.exdent();
}
}finally{
writer.exdent();
}
|
| public boolean | getBooleanParameter(java.lang.String parameter, boolean defaultValue)
int defaultInt = defaultValue ? 1 : 0;
int result = getIntParameter(parameter, defaultInt);
return result == 0 ? false : true;
|
| public boolean | getBooleanParameter(java.lang.String parameter)
ConfigurationDefaults def = ConfigurationDefaults.getInstance();
int result;
try {
result = getIntParameter(parameter, def.getIntParameter(parameter));
} catch (ConfigurationParameterNotFoundException e) {
result = getIntParameter(parameter, ConfigurationDefaults.def_boolean);
}
return result == 0 ? false : true;
|
| public byte[] | getByteParameter(java.lang.String parameter)
ConfigurationDefaults def = ConfigurationDefaults.getInstance();
byte[] result;
try {
result = getByteParameter(parameter, def.getByteParameter(parameter));
} catch (ConfigurationParameterNotFoundException e) {
result = getByteParameter(parameter, ConfigurationDefaults.def_bytes);
}
return result;
|
| public byte[] | getByteParameter(java.lang.String parameter, byte[] defaultValue)
byte[] tempValue = getByteParameterRaw(parameter);
return tempValue != null ? tempValue : defaultValue;
|
| private byte[] | getByteParameterRaw(java.lang.String parameter)
return (byte[]) propertiesMap.get(parameter);
|
| public java.lang.String | getDirectoryParameter(java.lang.String parameter)
String dir = getStringParameter(parameter);
if( dir.length() > 0 ) {
File temp = new File(dir);
if (!temp.exists()) {
FileUtil.mkdirs(temp);
}
if (!temp.isDirectory()) {
throw new IOException("Configuration error. This is not a directory: " + dir);
}
}
return dir;
|
| public float | getFloatParameter(java.lang.String parameter)
return( getFloatParameter( parameter, ConfigurationDefaults.def_float ));
|
| public float | getFloatParameter(java.lang.String parameter, float def_val)
ConfigurationDefaults def = ConfigurationDefaults.getInstance();
try {
Object o = propertiesMap.get(parameter);
if (o instanceof Number) {
return ((Number)o).floatValue();
}
String s = getStringParameter(parameter);
if (!s.equals(ConfigurationDefaults.def_String))
return Float.parseFloat(s);
} catch (Exception e) {
Debug.printStackTrace( e );
}
try {
return def.getFloatParameter(parameter);
} catch (Exception e2) {
return def_val;
}
|
| public static org.gudy.azureus2.core3.config.impl.ConfigurationManager | getInstance()
try{
class_mon.enter();
if ( config == null){
// this is nasty but I can't see an easy way around it. Unfortunately while reading the config
// we hit other code (logging for example) that needs access to the config data. Things are
// cunningly (?) arranged so that a recursive call here *won't* result in a further (looping)
// recursive call if we attempt to load the config again. Hence this disgusting code that
// goes for a second load attempt
if ( config_temp == null ){
config_temp = new ConfigurationManager();
config_temp.load();
config_temp.initialise();
config = config_temp;
}else{
if ( config_temp.propertiesMap == null ){
config_temp.load();
}
return( config_temp );
}
}
return config;
}finally{
class_mon.exit();
}
|
| public static org.gudy.azureus2.core3.config.impl.ConfigurationManager | getInstance(java.util.Map data)
try{
class_mon.enter();
if (config == null){
config = new ConfigurationManager(data);
}
return config;
}finally{
class_mon.exit();
}
|
| public int | getIntParameter(java.lang.String parameter, int defaultValue)
Long tempValue = getLongParameterRaw(parameter);
return tempValue != null ? tempValue.intValue() : defaultValue;
|
| public int | getIntParameter(java.lang.String parameter)
ConfigurationDefaults def = ConfigurationDefaults.getInstance();
int result;
try {
result = getIntParameter(parameter, def.getIntParameter(parameter));
} catch (ConfigurationParameterNotFoundException e) {
result = getIntParameter(parameter, ConfigurationDefaults.def_int);
}
return result;
|
| public java.util.List | getListParameter(java.lang.String parameter, java.util.List def)
try {
List rawList = (List) propertiesMap.get(parameter);
if(rawList == null)
return def;
return rawList;
} catch(Exception e) {
Debug.printStackTrace(e);
return def;
}
|
| public long | getLongParameter(java.lang.String parameter, long defaultValue)
Long tempValue = getLongParameterRaw(parameter);
return tempValue != null ? tempValue.longValue() : defaultValue;
|
| public long | getLongParameter(java.lang.String parameter)
ConfigurationDefaults def = ConfigurationDefaults.getInstance();
long result;
try {
result = getLongParameter(parameter, def.getLongParameter(parameter));
} catch (ConfigurationParameterNotFoundException e) {
result = getLongParameter(parameter, ConfigurationDefaults.def_long);
}
return result;
|
| private java.lang.Long | getLongParameterRaw(java.lang.String parameter)
try {
return (Long) propertiesMap.get(parameter);
} catch (Exception e) {
Debug.printStackTrace( e );
return null;
}
|
| public java.util.Map | getMapParameter(java.lang.String parameter, java.util.Map def)
try {
Map map = (Map) propertiesMap.get(parameter);
if(map == null)
return def;
return map;
} catch(Exception e) {
Debug.printStackTrace(e);
return def;
}
|
| public java.lang.Object | getParameter(java.lang.String name)
Object value = propertiesMap.get( name );
if ( value == null ){
value = ConfigurationDefaults.getInstance().getParameter( name );
}
return( value );
|
| public StringList | getStringListParameter(java.lang.String parameter)
try {
List rawList = (List) propertiesMap.get(parameter);
if(rawList == null)
return new StringListImpl();
return new StringListImpl(rawList);
} catch(Exception e) {
Debug.printStackTrace(e);
return new StringListImpl();
}
|
| private java.lang.String | getStringParameter(java.lang.String parameter, byte[] defaultValue)
byte[] bp = getByteParameter(parameter, defaultValue);
if ( bp == null ){
bp = getByteParameter(parameter, null);
}
if (bp == null)
return null;
return bytesToString(bp);
|
| public java.lang.String | getStringParameter(java.lang.String parameter, java.lang.String defaultValue)
String tempValue = getStringParameter(parameter, (byte[]) null);
return tempValue != null ? tempValue : defaultValue;
|
| public java.lang.String | getStringParameter(java.lang.String parameter)
ConfigurationDefaults def = ConfigurationDefaults.getInstance();
String result;
try {
result = getStringParameter(parameter, def.getStringParameter(parameter));
} catch (ConfigurationParameterNotFoundException e) {
result = getStringParameter(parameter, ConfigurationDefaults.def_String);
}
return result;
|
| public boolean | hasParameter(java.lang.String key, boolean explicit)Returns true if a parameter with the given name exists.
// We have an explicit value set.
if (propertiesMap.containsKey(key)) {return true;}
// We have a default value set.
if ((!explicit) && ConfigurationDefaults.getInstance().hasParameter(key)) {
return true;
}
return false;
|
| protected void | initialise()
//ConfigurationChecker.migrateConfig(); //removed 2201
ConfigurationChecker.checkConfiguration();
ConfigurationChecker.setSystemProperties();
AEDiagnostics.addEvidenceGenerator( this );
|
| public boolean | isNewInstall()
return( ConfigurationChecker.isNewInstall());
|
| public void | load(java.lang.String filename)
Map data = FileUtil.readResilientConfigFile( filename, false );
// horrendous recursive loading going on here due to logger + config depedencies. If already loaded
// then use the existing data as it might have already been written to...
if ( propertiesMap == null ){
propertiesMap = data;
}
/*
* Can't do this yet. Sometimes, there's a default set to x, but the code
* calls get..Parameter(..., y). y != x. When the user sets the the parameter
* to x, we remove it from the list. Later, the get..Parameter(.., y) returns
* y because there is no entry.
*
* The solution is to not allow get..Parameter(.., y) when there's a default
* value. Another reason to not allow it is that having two defaults confuses
* coders.
*
// Remove entries that are default. Saves memory, reduces
// file size when saved again
ConfigurationDefaults def = ConfigurationDefaults.getInstance();
Iterator it = new TreeSet(propertiesMap.keySet()).iterator();
while (it.hasNext()) {
String key = (String)it.next();
Object defValue = def.getDefaultValueAsObject(key);
if (defValue == null)
continue;
if (defValue instanceof Long) {
int iDefValue = ((Long)defValue).intValue();
int iValue = getIntParameter(key, iDefValue);
if (iValue == iDefValue)
propertiesMap.remove(key);
}
if (defValue instanceof String) {
String sDefValue = defValue.toString();
String sValue = getStringParameter(key, sDefValue);
if (sValue.compareTo(sDefValue) == 0)
propertiesMap.remove(key);
}
}
*/
|
| public void | load()
load("azureus.config");
|
| private void | notifyParameterListeners(java.lang.String parameter)
Vector parameterListener = (Vector) parameterListeners.get(parameter);
if (parameterListener == null) {
return;
}
Object[] listeners = parameterListener.toArray();
for (int i = 0; i < listeners.length; i++) {
ParameterListener listener = (ParameterListener) listeners[i];
if (listener != null) {
try {
listener.parameterChanged(parameter);
} catch (Throwable e) {
// we're not synchronized so possible but unlikely error here
Debug.printStackTrace(e);
}
}
}
|
| private boolean | notifyParameterListenersIfChanged(java.lang.String parameter, java.lang.Long newValue, java.lang.Long oldValue)
if(oldValue == null || 0 != newValue.compareTo(oldValue)) {
notifyParameterListeners(parameter);
return true;
}
return false;
|
| private boolean | notifyParameterListenersIfChanged(java.lang.String parameter, byte[] newValue, byte[] oldValue)
if(oldValue == null || !Arrays.equals(newValue, oldValue)) {
notifyParameterListeners(parameter);
return true;
}
return false;
|
| public void | removeListener(COConfigurationListener listener)
try{
this_mon.enter();
listeners.remove(listener);
}finally{
this_mon.exit();
}
|
| public boolean | removeParameter(java.lang.String parameter)Remove the given configuration parameter completely.
boolean removed = propertiesMap.remove( parameter ) != null;
if (removed)
notifyParameterListeners(parameter);
return removed;
|
| public void | removeParameterListener(java.lang.String parameter, ParameterListener listener)
try{
this_mon.enter();
if(parameter == null || listener == null)
return;
Vector parameterListener = (Vector) parameterListeners.get(parameter);
if(parameterListener != null) {
parameterListener.remove(listener);
}
}finally{
this_mon.exit();
}
|
| public boolean | removeRGBParameter(java.lang.String parameter)
boolean bAnyChanged = false;
bAnyChanged |= removeParameter(parameter + ".red");
bAnyChanged |= removeParameter(parameter + ".green");
bAnyChanged |= removeParameter(parameter + ".blue");
if (bAnyChanged)
notifyParameterListeners(parameter);
return bAnyChanged;
|
| public void | save(java.lang.String filename)
if ( propertiesMap == null ){
// nothing to save, initialisation not complete
return;
}
FileUtil.writeResilientConfigFile( filename, propertiesMap );
List listeners_copy;
try{
this_mon.enter();
listeners_copy = new ArrayList( listeners );
}finally{
this_mon.exit();
}
for (int i=0;i<listeners_copy.size();i++){
COConfigurationListener l = (COConfigurationListener)listeners_copy.get(i);
if (l != null){
try{
l.configurationSaved();
}catch( Throwable e ){
Debug.printStackTrace( e );
}
}else{
Debug.out("COConfigurationListener is null");
}
}
|
| public void | save()
save("azureus.config");
|
| public void | setDirty()
dirty_dispatcher.dispatch();
|
| public boolean | setParameter(java.lang.String parameter, boolean value)
return setParameter(parameter, value ? 1 : 0);
|
| public boolean | setParameter(java.lang.String parameter, StringList value)
try {
List encoded = new ArrayList();
List l = ((StringListImpl)value).getList();
for (int i=0;i<l.size();i++){
encoded.add( stringToBytes((String)l.get(i)));
}
propertiesMap.put(parameter,encoded);
} catch(Exception e) {
Debug.printStackTrace(e);
return false;
}
return true;
|
| public boolean | setParameter(java.lang.String parameter, java.util.List value)
try {
propertiesMap.put(parameter,value);
notifyParameterListeners(parameter);
} catch(Exception e) {
Debug.printStackTrace(e);
return false;
}
return true;
|
| public boolean | setParameter(java.lang.String parameter, java.util.Map value)
try {
propertiesMap.put(parameter,value);
notifyParameterListeners(parameter);
} catch(Exception e) {
Debug.printStackTrace(e);
return false;
}
return true;
|
| public boolean | setParameter(java.lang.String parameter, float defaultValue)
String newValue = String.valueOf(defaultValue);
return setParameter(parameter, stringToBytes(newValue));
|
| public boolean | setParameter(java.lang.String parameter, int defaultValue)
Long newValue = new Long(defaultValue);
try {
Long oldValue = (Long) propertiesMap.put(parameter, newValue);
return notifyParameterListenersIfChanged(parameter, newValue, oldValue);
} catch (ClassCastException e) {
// Issuing a warning here would be nice, but both logging and config stuff
// at startup create potential deadlocks or stack overflows
notifyParameterListeners(parameter);
return true;
}
|
| public boolean | setParameter(java.lang.String parameter, long defaultValue)
Long newValue = new Long(defaultValue);
try {
Long oldValue = (Long) propertiesMap.put(parameter, newValue);
return notifyParameterListenersIfChanged(parameter, newValue, oldValue);
} catch (ClassCastException e) {
// Issuing a warning here would be nice, but both logging and config stuff
// at startup create potential deadlocks or stack overflows
notifyParameterListeners(parameter);
return true;
}
|
| public boolean | setParameter(java.lang.String parameter, byte[] defaultValue)
try {
byte[] oldValue = (byte[]) propertiesMap.put(parameter, defaultValue);
return notifyParameterListenersIfChanged(parameter, defaultValue,
oldValue);
} catch (ClassCastException e) {
// Issuing a warning here would be nice, but both logging and config stuff
// at startup create potential deadlocks or stack overflows
notifyParameterListeners(parameter);
return true;
}
|
| public boolean | setParameter(java.lang.String parameter, java.lang.String defaultValue)
return setParameter(parameter, stringToBytes(defaultValue));
|
| public boolean | setParameter(java.lang.String parameter)
ConfigurationDefaults def = ConfigurationDefaults.getInstance();
try {
return setParameter(parameter, def.getIntParameter(parameter));
} catch (Exception e) {
return setParameter(parameter, def.getStringParameter(parameter));
}
|
| public boolean | setRGBParameter(java.lang.String parameter, int red, int green, int blue)
boolean bAnyChanged = false;
bAnyChanged |= setParameter(parameter + ".red", red);
bAnyChanged |= setParameter(parameter + ".green", green);
bAnyChanged |= setParameter(parameter + ".blue", blue);
if (bAnyChanged)
notifyParameterListeners(parameter);
return bAnyChanged;
|
| protected static byte[] | stringToBytes(java.lang.String str)
try{
return( str.getBytes( Constants.DEFAULT_ENCODING ));
}catch( Throwable e ){
return( str.getBytes());
}
|
| public boolean | verifyParameter(java.lang.String parameter, java.lang.String value)
List verifiers = ConfigurationDefaults.getInstance().getVerifiers(parameter);
if ( verifiers != null ){
try{
for (int i=0;i<verifiers.size();i++){
ParameterVerifier verifier = (ParameterVerifier)verifiers.get(i);
if ( verifier != null ){
try{
if ( !verifier.verify(parameter,value)){
return( false );
}
}catch( Throwable e ){
Debug.printStackTrace( e );
}
}
}
}catch( Throwable e ){
// we're not synchronized so possible but unlikely error here
Debug.printStackTrace( e );
}
}
return( true );
|
