♻️ Use handler for Sone insertion notifications
[Sone.git] / src / main / java / net / pterodactylus / sone / freenet / PluginStoreConfigurationBackend.java
1 /*
2  * Sone - PluginStoreConfigurationBackend.java - Copyright © 2010–2019 David Roden
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17
18 package net.pterodactylus.sone.freenet;
19
20 import static java.util.logging.Logger.getLogger;
21
22 import java.util.logging.Logger;
23
24 import net.pterodactylus.util.config.AttributeNotFoundException;
25 import net.pterodactylus.util.config.Configuration;
26 import net.pterodactylus.util.config.ConfigurationException;
27 import net.pterodactylus.util.config.ExtendedConfigurationBackend;
28 import freenet.client.async.PersistenceDisabledException;
29 import freenet.pluginmanager.PluginRespirator;
30 import freenet.pluginmanager.PluginStore;
31
32 /**
33  * Backend for a {@link Configuration} that is based on a {@link PluginStore}.
34  */
35 public class PluginStoreConfigurationBackend implements ExtendedConfigurationBackend {
36
37         /** The logger. */
38         @SuppressWarnings("unused")
39         private static final Logger logger = getLogger(PluginStoreConfigurationBackend.class.getName());
40
41         /** The plugin respirator. */
42         private final PluginRespirator pluginRespirator;
43
44         /** The backing plugin store. */
45         private final PluginStore pluginStore;
46
47         /**
48          * Creates a new configuration backend based on a plugin store.
49          *
50          * @param pluginRespirator
51          *            The plugin respirator
52          * @throws PersistenceDisabledException
53          *             if the plugin store is not available
54          */
55         public PluginStoreConfigurationBackend(PluginRespirator pluginRespirator) throws PersistenceDisabledException {
56                 this.pluginRespirator = pluginRespirator;
57                 this.pluginStore = pluginRespirator.getStore();
58         }
59
60         /**
61          * {@inheritDoc}
62          */
63         @Override
64         public String getValue(String attribute) throws ConfigurationException {
65                 if (!pluginStore.strings.containsKey(attribute)) {
66                         throw new AttributeNotFoundException(attribute);
67                 }
68                 return pluginStore.strings.get(attribute);
69         }
70
71         /**
72          * {@inheritDoc}
73          */
74         @Override
75         public void putValue(String attribute, String value) throws ConfigurationException {
76                 pluginStore.strings.put(attribute, value);
77                 save();
78         }
79
80         /**
81          * {@inheritDoc}
82          */
83         @Override
84         public Boolean getBooleanValue(String attribute) throws ConfigurationException {
85                 if (!pluginStore.booleans.containsKey(attribute)) {
86                         throw new AttributeNotFoundException(attribute);
87                 }
88                 return pluginStore.booleans.get(attribute);
89         }
90
91         /**
92          * {@inheritDoc}
93          */
94         @Override
95         public void setBooleanValue(String attribute, Boolean value) throws ConfigurationException {
96                 pluginStore.booleans.put(attribute, value);
97                 save();
98         }
99
100         /**
101          * {@inheritDoc}
102          */
103         @Override
104         public Double getDoubleValue(String attribute) throws ConfigurationException {
105                 if (!pluginStore.strings.containsKey(attribute)) {
106                         throw new AttributeNotFoundException(attribute);
107                 }
108                 String stringValue = pluginStore.strings.get(attribute);
109                 if (stringValue == null) {
110                         return null;
111                 }
112                 try {
113                         return Double.valueOf(pluginStore.strings.get(attribute));
114                 } catch (NumberFormatException nfe1) {
115                         throw new ConfigurationException("Could not parse “" + stringValue + "”.", nfe1);
116                 }
117         }
118
119         /**
120          * {@inheritDoc}
121          */
122         @Override
123         public void setDoubleValue(String attribute, Double value) throws ConfigurationException {
124                 pluginStore.strings.put(attribute, String.valueOf(value));
125                 save();
126         }
127
128         /**
129          * {@inheritDoc}
130          */
131         @Override
132         public Integer getIntegerValue(String attribute) throws ConfigurationException {
133                 if (!pluginStore.integers.containsKey(attribute)) {
134                         throw new AttributeNotFoundException(attribute);
135                 }
136                 return pluginStore.integers.get(attribute);
137         }
138
139         /**
140          * {@inheritDoc}
141          */
142         @Override
143         public void setIntegerValue(String attribute, Integer value) throws ConfigurationException {
144                 pluginStore.integers.put(attribute, value);
145                 save();
146         }
147
148         /**
149          * {@inheritDoc}
150          */
151         @Override
152         public Long getLongValue(String attribute) throws ConfigurationException {
153                 if (!pluginStore.longs.containsKey(attribute)) {
154                         throw new AttributeNotFoundException(attribute);
155                 }
156                 return pluginStore.longs.get(attribute);
157         }
158
159         /**
160          * {@inheritDoc}
161          */
162         @Override
163         public void setLongValue(String attribute, Long value) throws ConfigurationException {
164                 pluginStore.longs.put(attribute, value);
165                 save();
166         }
167
168         /**
169          * {@inheritDoc}
170          */
171         @Override
172         public void save() throws ConfigurationException {
173                 try {
174                         pluginRespirator.putStore(pluginStore);
175                 } catch (PersistenceDisabledException pde1) {
176                         throw new ConfigurationException("Could not store plugin store, persistence is disabled.", pde1);
177                 }
178         }
179
180 }