class ServerInfoConfig {
    private static final Logger logger = LoggerFactory.getLogger(ServerInfoConfig.class);

    public static final String CONFIG_NAME = "info";
    public static final String ENABLE_SERVER_INFO = "enableServerInfo";
    public static final String KEYS_TO_NOT_SORT = "keysToNotSort";
    private static final String DOWNSTREAM_ENABLED = "downstreamEnabled";
    private static final String DOWNSTREAM_HOST = "downstreamHost";
    private static final String DOWNSTREAM_PATH = "downstreamPath";
    private Map<String, Object> mappedConfig;
    private final Config config;
    boolean enableServerInfo;
    List<String> keysToNotSort;
    boolean downstreamEnabled;
    String downstreamHost;
    String downstreamPath;

    private ServerInfoConfig() {
        this(CONFIG_NAME);
    }

    private ServerInfoConfig(String configName) {
        config = Config.getInstance();
        mappedConfig = config.getJsonMapConfigNoCache(configName);
        setData();
        setList();
    }

    public static ServerInfoConfig load() {
        return new ServerInfoConfig();
    }

    public static ServerInfoConfig load(String configName) {
        return new ServerInfoConfig(configName);
    }

    public void reload() {
        mappedConfig = config.getJsonMapConfigNoCache(CONFIG_NAME);
        setData();
        setList();
    }

    public Map<String, Object> getMappedConfig() {
        return mappedConfig;
    }

    public Config getConfig() {
        return config;
    }

    public List<String> getKeysToNotSort() {
        return keysToNotSort;
    }

    public boolean isEnableServerInfo() {
        return enableServerInfo;
    }

    public void setEnableServerInfo(boolean enableServerInfo) {
        this.enableServerInfo = enableServerInfo;
    }

    public boolean isDownstreamEnabled() {
        return downstreamEnabled;
    }

    public void setDownstreamEnabled(boolean downstreamEnabled) {
        this.downstreamEnabled = downstreamEnabled;
    }

    public String getDownstreamHost() {
        return downstreamHost;
    }

    public void setDownstreamHost(String downstreamHost) {
        this.downstreamHost = downstreamHost;
    }

    public String getDownstreamPath() {
        return downstreamPath;
    }

    public void setDownstreamPath(String downstreamPath) {
        this.downstreamPath = downstreamPath;
    }

    private void setData() {
        Object object = mappedConfig.get(ENABLE_SERVER_INFO);
        if(object != null) enableServerInfo = Config.loadBooleanValue(ENABLE_SERVER_INFO, object);
        object = getMappedConfig().get(DOWNSTREAM_ENABLED);
        if(object != null) downstreamEnabled = Config.loadBooleanValue(DOWNSTREAM_ENABLED, object);
        object = getMappedConfig().get(DOWNSTREAM_HOST);
        if(object != null) downstreamHost = (String)object;
        object = getMappedConfig().get(DOWNSTREAM_PATH);
        if(object != null) downstreamPath = (String)object;
    }

    private void setList() {<FILL_FUNCTION_BODY>}
}

        if(mappedConfig.get(KEYS_TO_NOT_SORT) instanceof String) {
            String s = (String)mappedConfig.get(KEYS_TO_NOT_SORT);
            s = s.trim();
            if(logger.isTraceEnabled()) logger.trace("s = " + s);
            if(s.startsWith("[")) {
                // this is a JSON string, and we need to parse it.
                try {
                    keysToNotSort = Config.getInstance().getMapper().readValue(s, new TypeReference<List<String>>() {});
                } catch (Exception e) {
                    throw new ConfigException("could not parse the keysToNotSort json with a list of strings.");
                }
            } else {
                // this is a comma separated string.
                keysToNotSort = Arrays.asList(s.split("\\s*,\\s*"));
            }
        } else if (getMappedConfig().get(KEYS_TO_NOT_SORT) instanceof List) {
            keysToNotSort = (List<String>) mappedConfig.get(KEYS_TO_NOT_SORT);
        } else {
            keysToNotSort = Arrays.asList("admin","default","defaultHandlers");
        }
    
<no_super_class>