Configurable.java

Go to the documentation of this file.

/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.lang;
 
import java.lang.reflect.Field;
 
import javolution.context.LogContext;
import javolution.context.SecurityContext;
import javolution.context.SecurityContext.Permission;
import javolution.osgi.internal.OSGiServices;
import javolution.text.DefaultTextFormat;
import javolution.text.TextContext;
 
public abstract class Configurable<T> {
 
    public interface Listener {
 
        <T> void configurableInitialized(Configurable<T> configurable, T value);
 
        <T> void configurableReconfigured(Configurable<T> configurable,
                T oldValue, T newValue);
 
    }
 
    public static Permission<Configurable<?>> RECONFIGURE_PERMISSION = new Permission<Configurable<?>>(
            Configurable.class, "reconfigure");
 
    private String name;
 
    private final Permission<Configurable<T>> reconfigurePermission;
 
    private volatile T value;
 
    public Configurable() {
        reconfigurePermission = new Permission<Configurable<T>>(
                Configurable.class, "reconfigure", this);
        String name = getName();
        T defaultValue = getDefault();
        if (name != null) {
            try { // Checks system properties.
                String property = System.getProperty(name);
                if (property != null) {
                    defaultValue = parse(property); // Supersedes.
                    LogContext.debug(name, ", System Properties Value: ",
                            defaultValue);
                }
            } catch (SecurityException securityError) {
                // Ok, current runtime does not allow system properties access.
            }
        }
        this.name = name;
        this.value = initialized(defaultValue);
        Object[] listeners = OSGiServices.getConfigurableListeners();
        for (Object listener : listeners) {
            ((Listener) listener).configurableInitialized(this, this.value);
        }
    }
 
    public T get() {
        return value;
    }
 
    public String getName() {
        if (name != null)
            return name; // Already set.
        Class<?> thisClass = this.getClass();
        Class<?> enclosingClass = thisClass.getEnclosingClass();
        String fieldName = null;
        for (Field field : enclosingClass.getFields()) {
            if (field.getType().isAssignableFrom(thisClass)) {
                if (fieldName != null) // Indistinguishable field types.
                    throw new UnsupportedOperationException(
                       "Multiple configurables static fields in the same class" +
                       "requires the Configurable.getName() method to be overriden.");
                fieldName = field.getName();
            }
        }
        return (fieldName != null) ? enclosingClass.getName() + "#" + fieldName
                : null;
    }
 
    public Permission<Configurable<T>> getReconfigurePermission() {
        return reconfigurePermission;
    }
 
    public T reconfigure(T newValue) {
        SecurityContext.check(reconfigurePermission);
        synchronized (this) {
            T oldValue = this.value;
            this.value = reconfigured(oldValue, newValue);
            Object[] listeners = OSGiServices.getConfigurableListeners();
            for (Object listener : listeners) {
                ((Listener) listener).configurableReconfigured(this, oldValue,
                        this.value);
            }
            return this.value;
        }
    }
 
    protected abstract T getDefault();
 
    protected T initialized(T value) {
        return value;
    }
 
    @SuppressWarnings("unchecked")
    protected T parse(String str) {
        Class<? extends T> type = (Class<? extends T>) getDefault().getClass();
        return TextContext.getFormat(type).parse(str);
    }
 
    protected T reconfigured(T oldValue, T newValue) {
        return newValue;
    }
}