common/onap-common-configuration-management/onap-configuration-management-api/src/main/java/org/onap/config/api/Configuration.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.config.api;
  18
  19 import java.util.Arrays;
  20 import java.util.Collections;
  21 import java.util.List;
  22 import java.util.Map;
  23
  24 public interface Configuration {
  25
  26     ThreadLocal<String> TENANT = new ThreadLocal<>();
  27
  28     /**
  29      * Sets tenant for current thread.
  30      *
  31      * @param id tenant id; may be <code>null</code> in which case a default will be used.
  32      */
  33     static void setTenantId(String id) {
  34
  35         if (id != null && id.trim().length() > 0) {
  36             TENANT.set(id);
  37         } else {
  38             TENANT.remove();
  39         }
  40     }
  41
  42     default String getAsString(String key) {
  43         return getAsString(null, key);
  44     }
  45
  46     default String getAsString(String namespace, String key) {
  47         return getAsString(TENANT.get(), namespace, key);
  48     }
  49
  50     default String getAsString(String tenantId, String namespace, String key) {
  51         return get(tenantId, namespace, key, String.class);
  52     }
  53
  54     <T> T get(String tenant, String namespace, String key, Class<T> clazz, Hint... hints);
  55
  56     default Byte getAsByteValue(String key) {
  57         return getAsByteValue(null, key);
  58     }
  59
  60     default Byte getAsByteValue(String namespace, String key) {
  61         return getAsByteValue(TENANT.get(), namespace, key);
  62     }
  63
  64     default Byte getAsByteValue(String tenantId, String namespace, String key) {
  65         return get(tenantId, namespace, key, Byte.class);
  66     }
  67
  68     default Short getAsShortValue(String key) {
  69         return getAsShortValue(null, key);
  70     }
  71
  72     default Short getAsShortValue(String namespace, String key) {
  73         return getAsShortValue(TENANT.get(), namespace, key);
  74     }
  75
  76     default Short getAsShortValue(String tenantId, String namespace, String key) {
  77         return get(tenantId, namespace, key, Short.class);
  78     }
  79
  80     default Integer getAsIntegerValue(String key) {
  81         return getAsIntegerValue(null, key);
  82     }
  83
  84     default Integer getAsIntegerValue(String namespace, String key) {
  85         return getAsIntegerValue(TENANT.get(), namespace, key);
  86     }
  87
  88     default Integer getAsIntegerValue(String tenantId, String namespace, String key) {
  89         return get(tenantId, namespace, key, Integer.class);
  90     }
  91
  92     default Long getAsLongValue(String key) {
  93         return getAsLongValue(null, key);
  94     }
  95
  96     default Long getAsLongValue(String namespace, String key) {
  97         return getAsLongValue(TENANT.get(), namespace, key);
  98     }
  99
 100     default Long getAsLongValue(String tenantId, String namespace, String key) {
 101         return get(tenantId, namespace, key, Long.class);
 102     }
 103
 104     default Float getAsFloatValue(String key) {
 105         return getAsFloatValue(null, key);
 106     }
 107
 108     default Float getAsFloatValue(String namespace, String key) {
 109         return getAsFloatValue(TENANT.get(), namespace, key);
 110     }
 111
 112     default Float getAsFloatValue(String tenantId, String namespace, String key) {
 113         return get(tenantId, namespace, key, Float.class);
 114     }
 115
 116     default Double getAsDoubleValue(String key) {
 117         return getAsDoubleValue(null, key);
 118     }
 119
 120     default Double getAsDoubleValue(String namespace, String key) {
 121         return getAsDoubleValue(TENANT.get(), namespace, key);
 122     }
 123
 124     default Double getAsDoubleValue(String tenantId, String namespace, String key) {
 125         return get(tenantId, namespace, key, Double.class);
 126     }
 127
 128     default Boolean getAsBooleanValue(String key) {
 129         return getAsBooleanValue(null, key);
 130     }
 131
 132     default Boolean getAsBooleanValue(String namespace, String key) {
 133         return getAsBooleanValue(TENANT.get(), namespace, key);
 134     }
 135
 136     default Boolean getAsBooleanValue(String tenantId, String namespace, String key) {
 137         return get(tenantId, namespace, key, Boolean.class);
 138     }
 139
 140     default Character getAsCharValue(String key) {
 141         return getAsCharValue(null, key);
 142     }
 143
 144     default Character getAsCharValue(String namespace, String key) {
 145         return getAsCharValue(TENANT.get(), namespace, key);
 146     }
 147
 148     default Character getAsCharValue(String tenantId, String namespace, String key) {
 149         return get(tenantId, namespace, key, Character.class);
 150     }
 151
 152     default <T> T populateConfiguration(Class<T> clazz) {
 153         return populateConfiguration(null, clazz);
 154     }
 155
 156     default <T> T populateConfiguration(String namespace, Class<T> clazz) {
 157         return populateConfiguration(TENANT.get(), namespace, clazz);
 158     }
 159
 160     default <T> T populateConfiguration(String tenantId, String namespace, Class<T> clazz) {
 161         return get(tenantId, namespace, null, clazz, Hint.EXTERNAL_LOOKUP);
 162     }
 163
 164     default <T> DynamicConfiguration<T> getDynamicConfiguration(String key, Class<T> clazz, T defaultValue) {
 165         return getDynamicConfiguration(null, key, clazz, defaultValue);
 166     }
 167
 168     default <T> DynamicConfiguration<T> getDynamicConfiguration(String namespace, String key, Class<T> clazz,
 169             T defaultValue) {
 170         return getDynamicConfiguration(TENANT.get(), namespace, key, clazz, defaultValue);
 171     }
 172
 173     default <T> DynamicConfiguration<T> getDynamicConfiguration(String tenant, String namespace, String key,
 174             Class<T> clazz, T defaultValue) {
 175         return DynamicConfiguration.getDynamicConfiguration(tenant, namespace, key, clazz, defaultValue, this);
 176     }
 177
 178     default <T> DynamicConfiguration<List<T>> getDynamicConfigurationValues(String key, Class<T> clazz,
 179             T defaultValue) {
 180         return getDynamicConfigurationValues(null, key, clazz, defaultValue);
 181     }
 182
 183     default <T> DynamicConfiguration<List<T>> getDynamicConfigurationValues(String namespace, String key,
 184             Class<T> clazz, T defaultValue) {
 185         return getDynamicConfigurationValues(TENANT.get(), namespace, key, clazz, defaultValue);
 186     }
 187
 188     default <T> DynamicConfiguration<List<T>> getDynamicConfigurationValues(String tenant, String namespace, String key,
 189             Class<T> clazz, T defaultValue) {
 190         return DynamicConfiguration.getDynConfiguration(tenant, namespace, key, clazz, defaultValue, this);
 191     }
 192
 193     default List<String> getAsStringValues(String key) {
 194         return getAsStringValues(null, key);
 195     }
 196
 197     default List<String> getAsStringValues(String namespace, String key) {
 198         return getAsStringValues(TENANT.get(), namespace, key);
 199     }
 200
 201     default List<String> getAsStringValues(String tenantId, String namespace, String key) {
 202         String[] tempArray = get(tenantId, namespace, key, String[].class);
 203         return tempArray == null ? Collections.emptyList() : Arrays.asList(tempArray);
 204     }
 205
 206     default List<Byte> getAsByteValues(String key) {
 207         return getAsByteValues(null, key);
 208     }
 209
 210     default List<Byte> getAsByteValues(String namespace, String key) {
 211         return getAsByteValues(TENANT.get(), namespace, key);
 212     }
 213
 214     default List<Byte> getAsByteValues(String tenantId, String namespace, String key) {
 215         Byte[] tempArray = get(tenantId, namespace, key, Byte[].class);
 216         return tempArray == null ? Collections.emptyList() : Arrays.asList(tempArray);
 217     }
 218
 219     default List<Short> getAsShortValues(String key) {
 220         return getAsShortValues(null, key);
 221     }
 222
 223     default List<Short> getAsShortValues(String namespace, String key) {
 224         return getAsShortValues(TENANT.get(), namespace, key);
 225     }
 226
 227     default List<Short> getAsShortValues(String tenantId, String namespace, String key) {
 228         Short[] tempArray = get(tenantId, namespace, key, Short[].class);
 229         return tempArray == null ? Collections.emptyList() : Arrays.asList(tempArray);
 230     }
 231
 232     default List<Integer> getAsIntegerValues(String key) {
 233         return getAsIntegerValues(null, key);
 234     }
 235
 236     default List<Integer> getAsIntegerValues(String namespace, String key) {
 237         return getAsIntegerValues(TENANT.get(), namespace, key);
 238     }
 239
 240     default List<Integer> getAsIntegerValues(String tenantId, String namespace, String key) {
 241         Integer[] tempArray = get(tenantId, namespace, key, Integer[].class);
 242         return tempArray == null ? Collections.emptyList() : Arrays.asList(tempArray);
 243     }
 244
 245     default List<Double> getAsDoubleValues(String key) {
 246         return getAsDoubleValues(null, key);
 247     }
 248
 249     default List<Double> getAsDoubleValues(String namespace, String key) {
 250         return getAsDoubleValues(TENANT.get(), namespace, key);
 251     }
 252
 253     default List<Double> getAsDoubleValues(String tenantId, String namespace, String key) {
 254         Double[] tempArray = get(tenantId, namespace, key, Double[].class);
 255         return tempArray == null ? Collections.emptyList() : Arrays.asList(tempArray);
 256     }
 257
 258     default List<Float> getAsFloatValues(String key) {
 259         return getAsFloatValues(null, key);
 260     }
 261
 262     default List<Float> getAsFloatValues(String namespace, String key) {
 263         return getAsFloatValues(TENANT.get(), namespace, key);
 264     }
 265
 266     default List<Float> getAsFloatValues(String tenantId, String namespace, String key) {
 267         Float[] tempArray = get(tenantId, namespace, key, Float[].class);
 268         return tempArray == null ? Collections.emptyList() : Arrays.asList(tempArray);
 269     }
 270
 271     default List<Boolean> getAsBooleanValues(String key) {
 272         return getAsBooleanValues(null, key);
 273     }
 274
 275     default List<Boolean> getAsBooleanValues(String namespace, String key) {
 276         return getAsBooleanValues(TENANT.get(), namespace, key);
 277     }
 278
 279     default List<Boolean> getAsBooleanValues(String tenantId, String namespace, String key) {
 280         Boolean[] tempArray = get(tenantId, namespace, key, Boolean[].class);
 281         return tempArray == null ? Collections.emptyList() : Arrays.asList(tempArray);
 282     }
 283
 284     default List<Character> getAsCharacterValues(String key) {
 285         return getAsCharacterValues(null, key);
 286     }
 287
 288     default List<Character> getAsCharacterValues(String namespace, String key) {
 289         return getAsCharacterValues(TENANT.get(), namespace, key);
 290     }
 291
 292     default List<Character> getAsCharacterValues(String tenantId, String namespace, String key) {
 293         Character[] tempArray = get(tenantId, namespace, key, Character[].class);
 294         return tempArray == null ? Collections.emptyList() : Arrays.asList(tempArray);
 295     }
 296
 297     default void addConfigurationChangeListener(String key, ConfigurationChangeListener myself) {
 298         addConfigurationChangeListener(null, key, myself);
 299     }
 300
 301     default void addConfigurationChangeListener(String namespace, String key, ConfigurationChangeListener myself) {
 302         addConfigurationChangeListener(TENANT.get(), namespace, key, myself);
 303     }
 304
 305     void addConfigurationChangeListener(String tenant, String namespace, String key,
 306             ConfigurationChangeListener myself);
 307
 308     default void removeConfigurationChangeListener(String key, ConfigurationChangeListener myself) {
 309         removeConfigurationChangeListener(null, key, myself);
 310     }
 311
 312     default void removeConfigurationChangeListener(String namespace, String key, ConfigurationChangeListener myself) {
 313         removeConfigurationChangeListener(TENANT.get(), namespace, key, myself);
 314     }
 315
 316     void removeConfigurationChangeListener(String tenant, String namespace, String key,
 317             ConfigurationChangeListener myself);
 318
 319     default <T> Map<String, T> populateMap(String key, Class<T> clazz) {
 320         return populateMap(null, key, clazz);
 321     }
 322
 323     default <T> Map<String, T> populateMap(String namespace, String key, Class<T> clazz) {
 324         return populateMap(TENANT.get(), namespace, key, clazz);
 325     }
 326
 327     <T> Map<String, T> populateMap(String tenantId, String namespace, String key, Class<T> clazz);
 328
 329     default Map generateMap(String key) {
 330         return generateMap(null, key);
 331     }
 332
 333     default Map generateMap(String namespace, String key) {
 334         return generateMap(TENANT.get(), namespace, key);
 335     }
 336
 337     Map generateMap(String tenantId, String namespace, String key);
 338 }