src/main/java/net/pterodactylus/sone/core/Options.java

   1 package net.pterodactylus.sone.core;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.Collections;
   6 import java.util.HashMap;
   7 import java.util.List;
   8 import java.util.Map;
   9
  10 /**
  11  * Stores various options that influence Sone’s behaviour.
  12  *
  13  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  14  */
  15 public class Options {
  16
  17         /**
  18          * Contains current and default value of an option.
  19          *
  20          * @param <T>
  21          *            The type of the option
  22          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  23          */
  24         public static interface Option<T> {
  25
  26                 /**
  27                  * Returns the default value of the option.
  28                  *
  29                  * @return The default value of the option
  30                  */
  31                 public T getDefault();
  32
  33                 /**
  34                  * Returns the current value of the option. If the current value is not
  35                  * set (usually {@code null}), the default value is returned.
  36                  *
  37                  * @return The current value of the option
  38                  */
  39                 public T get();
  40
  41                 /**
  42                  * Returns the real value of the option. This will also return an unset
  43                  * value (usually {@code null})!
  44                  *
  45                  * @return The real value of the option
  46                  */
  47                 public T getReal();
  48
  49                 /**
  50                  * Sets the current value of the option.
  51                  *
  52                  * @param value
  53                  *            The new value of the option
  54                  */
  55                 public void set(T value);
  56
  57         }
  58
  59         /**
  60          * Interface for objects that want to be notified when an option changes its
  61          * value.
  62          *
  63          * @param <T>
  64          *            The type of the option
  65          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  66          */
  67         public static interface OptionWatcher<T> {
  68
  69                 /**
  70                  * Notifies an object that an option has been changed.
  71                  *
  72                  * @param option
  73                  *            The option that has changed
  74                  * @param oldValue
  75                  *            The old value of the option
  76                  * @param newValue
  77                  *            The new value of the option
  78                  */
  79                 public void optionChanged(Option<T> option, T oldValue, T newValue);
  80
  81         }
  82
  83         /**
  84          * Basic implementation of an {@link Option} that notifies an
  85          * {@link OptionWatcher} if the value changes.
  86          *
  87          * @param <T>
  88          *            The type of the option
  89          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  90          */
  91         public static class DefaultOption<T> implements Option<T> {
  92
  93                 /** The default value. */
  94                 private final T defaultValue;
  95
  96                 /** The current value. */
  97                 private volatile T value;
  98
  99                 /** The option watcher. */
 100                 private final List<OptionWatcher<T>> optionWatchers = new ArrayList<OptionWatcher<T>>();
 101
 102                 /**
 103                  * Creates a new default option.
 104                  *
 105                  * @param defaultValue
 106                  *            The default value of the option
 107                  * @param optionWatchers
 108                  *            The option watchers
 109                  */
 110                 public DefaultOption(T defaultValue, OptionWatcher<T>... optionWatchers) {
 111                         this.defaultValue = defaultValue;
 112                         this.optionWatchers.addAll(Arrays.asList(optionWatchers));
 113                 }
 114
 115                 /**
 116                  * {@inheritDoc}
 117                  */
 118                 @Override
 119                 public T getDefault() {
 120                         return defaultValue;
 121                 }
 122
 123                 /**
 124                  * {@inheritDoc}
 125                  */
 126                 @Override
 127                 public T get() {
 128                         return (value != null) ? value : defaultValue;
 129                 }
 130
 131                 /**
 132                  * Returns the real value of the option. This will also return an unset
 133                  * value (usually {@code null})!
 134                  *
 135                  * @return The real value of the option
 136                  */
 137                 @Override
 138                 public T getReal() {
 139                         return value;
 140                 }
 141
 142                 /**
 143                  * {@inheritDoc}
 144                  */
 145                 @Override
 146                 public void set(T value) {
 147                         T oldValue = this.value;
 148                         this.value = value;
 149                         if (!get().equals(oldValue)) {
 150                                 for (OptionWatcher<T> optionWatcher : optionWatchers) {
 151                                         optionWatcher.optionChanged(this, oldValue, get());
 152                                 }
 153                         }
 154                 }
 155
 156         }
 157
 158         /** Holds all {@link Boolean} {@link Option}s. */
 159         private final Map<String, Option<Boolean>> booleanOptions = Collections.synchronizedMap(new HashMap<String, Option<Boolean>>());
 160
 161         /** Holds all {@link Integer} {@link Option}s. */
 162         private final Map<String, Option<Integer>> integerOptions = Collections.synchronizedMap(new HashMap<String, Option<Integer>>());
 163
 164         /** Holds all {@link String} {@link Option}s. */
 165         private final Map<String, Option<String>> stringOptions = Collections.synchronizedMap(new HashMap<String, Option<String>>());
 166
 167         /**
 168          * Adds a boolean option.
 169          *
 170          * @param name
 171          *            The name of the option
 172          * @param booleanOption
 173          *            The option
 174          * @return The given option
 175          */
 176         public Option<Boolean> addBooleanOption(String name, Option<Boolean> booleanOption) {
 177                 booleanOptions.put(name, booleanOption);
 178                 return booleanOption;
 179         }
 180
 181         /**
 182          * Returns the boolean option with the given name.
 183          *
 184          * @param name
 185          *            The name of the option
 186          * @return The option, or {@code null} if there is no option with the given
 187          *         name
 188          */
 189         public Option<Boolean> getBooleanOption(String name) {
 190                 return booleanOptions.get(name);
 191         }
 192
 193         /**
 194          * Adds an {@link Integer} {@link Option}.
 195          *
 196          * @param name
 197          *            The name of the option
 198          * @param integerOption
 199          *            The option
 200          * @return The given option
 201          */
 202         public Option<Integer> addIntegerOption(String name, Option<Integer> integerOption) {
 203                 integerOptions.put(name, integerOption);
 204                 return integerOption;
 205         }
 206
 207         /**
 208          * Returns an {@link Integer} {@link Option}.
 209          *
 210          * @param name
 211          *            The name of the integer option to get
 212          * @return The integer option, or {@code null} if there is no option with
 213          *         the given name
 214          */
 215         public Option<Integer> getIntegerOption(String name) {
 216                 return integerOptions.get(name);
 217         }
 218
 219         /**
 220          * Adds a {@link String} {@link Option}.
 221          *
 222          * @param name
 223          *            The name of the option
 224          * @param stringOption
 225          *            The option
 226          * @return The given option
 227          */
 228         public Option<String> addStringOption(String name, Option<String> stringOption) {
 229                 stringOptions.put(name, stringOption);
 230                 return stringOption;
 231         }
 232
 233         /**
 234          * Returns a {@link String} {@link Option}.
 235          *
 236          * @param name
 237          *            The name of the string option to get
 238          * @return The string option, or {@code null} if there is no option with the
 239          *         given name
 240          */
 241         public Option<String> getStringOption(String name) {
 242                 return stringOptions.get(name);
 243         }
 244
 245 }