gt:     if (StringUtils.isNotEmpty(value)) {
context: /*
   * SonarQube
   * Copyright (C) 2009-2019 SonarSource SA
   * mailto:info AT sonarsource DOT com
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 3 of the License, or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with this program; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   */
  package org.sonar.api.config;
  
  import com.google.common.base.Splitter;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  import java.util.Map;
  import java.util.Optional;
  import java.util.Properties;
  import java.util.stream.Collectors;
  import javax.annotation.CheckForNull;
  import javax.annotation.Nullable;
  import org.apache.commons.lang.ArrayUtils;
  import org.apache.commons.lang.StringUtils;
  import org.sonar.api.scanner.ScannerSide;
  import org.sonar.api.ce.ComputeEngineSide;
  import org.sonar.api.server.ServerSide;
  import org.sonar.api.utils.DateUtils;
  import org.sonarsource.api.sonarlint.SonarLintSide;
  
  import static java.util.Objects.requireNonNull;
  import static org.apache.commons.lang.StringUtils.trim;
  
  /**
   * @deprecated since 6.5 use {@link Configuration}
   */
  @ServerSide
  @ComputeEngineSide
  @ScannerSide
  @SonarLintSide
  @Deprecated
  public abstract class Settings {
  
    private final PropertyDefinitions definitions;
    private final Encryption encryption;
  
    protected Settings(PropertyDefinitions definitions, Encryption encryption) {
      this.definitions = requireNonNull(definitions);
      this.encryption = requireNonNull(encryption);
    }
  
    protected abstract Optional<String> get(String key);
  
    /**
     * Add the settings with the specified key and value, both are trimmed and neither can be null.
     *
     * @throws NullPointerException if {@code key} and/or {@code value} is {@code null}.
     */
    protected abstract void set(String key, String value);
  
    protected abstract void remove(String key);
  
    /**
     * Immutable map of the properties that have non-default values.
     * The default values defined by {@link PropertyDefinitions} are ignored,
     * so the returned values are not the effective values. Basically only
     * the non-empty results of {@link #getRawString(String)} are returned.
     * <p>
     * Values are not decrypted if they are encrypted with a secret key.
     * </p>
     */
    public abstract Map<String, String> getProperties();
  
    public Encryption getEncryption() {
      return encryption;
    }
  
    /**
     * The value that overrides the default value. It
     * may be encrypted with a secret key. Use {@link #getString(String)} to get
     * the effective and decrypted value.
     *
     * @since 6.1
     */
    public Optional<String> getRawString(String key) {
      return get(definitions.validKey(requireNonNull(key)));
    }
  
    /**
     * All the property definitions declared by core and plugins.
     */
    public PropertyDefinitions getDefinitions() {
      return definitions;
    }
  
    /**
     * The definition related to the specified property. It may
     * be empty.
     *
     * @since 6.1
     */
    public Optional<PropertyDefinition> getDefinition(String key) {
      return Optional.ofNullable(definitions.get(key));
    }
  
    /**
     * @return {@code true} if the property has a non-default value, else {@code false}.
     */
    public boolean hasKey(String key) {
      return getRawString(key).isPresent();
    }
  
    @CheckForNull
    public String getDefaultValue(String key) {
      return definitions.getDefaultValue(key);
    }
  
    public boolean hasDefaultValue(String key) {
      return StringUtils.isNotEmpty(getDefaultValue(key));
    }
  
    /**
     * The effective value of the specified property. Can return
     * {@code null} if the property is not set and has no
     * defined default value.
     * <p>
     * If the property is encrypted with a secret key,
     * then the returned value is decrypted.
     * </p>
     *
     * @throws IllegalStateException if value is encrypted but fails to be decrypted.
     */
    @CheckForNull
    public String getString(String key) {
      String effectiveKey = definitions.validKey(key);
      Optional<String> value = getRawString(effectiveKey);
      if (!value.isPresent()) {
        // default values cannot be encrypted, so return value as-is.
        return getDefaultValue(effectiveKey);
      }
      if (encryption.isEncrypted(value.get())) {
        try {
          return encryption.decrypt(value.get());
        } catch (Exception e) {
          throw new IllegalStateException("Fail to decrypt the property " + effectiveKey + ". Please check your secret key.", e);
        }
      }
      return value.get();
    }
  
    /**
     * Effective value as boolean. It is {@code false} if {@link #getString(String)}
     * does not return {@code "true"}, even if it's not a boolean representation.
     * @return {@code true} if the effective value is {@code "true"}, else {@code false}.
     */
    public boolean getBoolean(String key) {
      String value = getString(key);
      return StringUtils.isNotEmpty(value) && Boolean.parseBoolean(value);
    }
  
    /**
     * Effective value as {@code int}.
     * @return the value as {@code int}. If the property does not have value nor default value, then {@code 0} is returned.
     * @throws NumberFormatException if value is not empty and is not a parsable integer
     */
    public int getInt(String key) {
      String value = getString(key);
      if (StringUtils.isNotEmpty(value)) {
        return Integer.parseInt(value);
      }
      return 0;
    }
  
    /**
     * Effective value as {@code long}.
     * @return the value as {@code long}. If the property does not have value nor default value, then {@code 0L} is returned.
     * @throws NumberFormatException if value is not empty and is not a parsable {@code long}
     */
    public long getLong(String key) {
      String value = getString(key);
      if (StringUtils.isNotEmpty(value)) {
        return Long.parseLong(value);
      }
      return 0L;
    }
  
    /**
     * Effective value as {@link Date}, without time fields. Format is {@link DateUtils#DATE_FORMAT}.
     *
     * @return the value as a {@link Date}. If the property does not have value nor default value, then {@code null} is returned.
     * @throws RuntimeException if value is not empty and is not in accordance with {@link DateUtils#DATE_FORMAT}.
     */
    @CheckForNull
    public Date getDate(String key) {
      String value = getString(key);
  