org.ini4j.ConfigParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ini4j Show documentation
Show all versions of ini4j Show documentation
Java API for handling configuration files in Windows .ini format. The library includes its own Map based API, Java Preferences API and Java Beans API for handling .ini files. Additionally, the library includes a feature rich (variable/macro substitution, multiply property values, etc) java.util.Properties replacement.
/*
* Copyright 2005,2009 Ivan SZKIBA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ini4j;
import org.ini4j.spi.IniHandler;
import org.ini4j.spi.Warnings;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Serializable;
import java.io.Writer;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ConfigParser implements Serializable
{
private static final long serialVersionUID = 9118857036229164353L;
private PyIni _ini;
@SuppressWarnings(Warnings.UNCHECKED)
public ConfigParser()
{
this(Collections.EMPTY_MAP);
}
public ConfigParser(Map defaults)
{
_ini = new PyIni(defaults);
}
public boolean getBoolean(String section, String option) throws NoSectionException, NoOptionException, InterpolationException
{
boolean ret;
String value = get(section, option);
if ("1".equalsIgnoreCase(value) || "yes".equalsIgnoreCase(value) || "true".equalsIgnoreCase(value) || "on".equalsIgnoreCase(value))
{
ret = true;
}
else if ("0".equalsIgnoreCase(value) || "no".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value)
|| "off".equalsIgnoreCase(value))
{
ret = false;
}
else
{
throw new IllegalArgumentException(value);
}
return ret;
}
public double getDouble(String section, String option) throws NoSectionException, NoOptionException, InterpolationException
{
return Double.parseDouble(get(section, option));
}
public float getFloat(String section, String option) throws NoSectionException, NoOptionException, InterpolationException
{
return Float.parseFloat(get(section, option));
}
public int getInt(String section, String option) throws NoSectionException, NoOptionException, InterpolationException
{
return Integer.parseInt(get(section, option));
}
public long getLong(String section, String option) throws NoSectionException, NoOptionException, InterpolationException
{
return Long.parseLong(get(section, option));
}
public void addSection(String section) throws DuplicateSectionException
{
if (_ini.containsKey(section))
{
throw new DuplicateSectionException(section);
}
else if (PyIni.DEFAULT_SECTION_NAME.equalsIgnoreCase(section))
{
throw new IllegalArgumentException(section);
}
_ini.add(section);
}
public Map defaults()
{
return _ini.getDefaults();
}
@SuppressWarnings(Warnings.UNCHECKED)
public String get(String section, String option) throws NoSectionException, NoOptionException, InterpolationException
{
return get(section, option, false, Collections.EMPTY_MAP);
}
@SuppressWarnings(Warnings.UNCHECKED)
public String get(String section, String option, boolean raw) throws NoSectionException, NoOptionException, InterpolationException
{
return get(section, option, raw, Collections.EMPTY_MAP);
}
public String get(String sectionName, String optionName, boolean raw, Map variables) throws NoSectionException,
NoOptionException, InterpolationException
{
String value = requireOption(sectionName, optionName);
if (!raw && (value != null) && (value.indexOf(PyIni.SUBST_CHAR) >= 0))
{
value = _ini.fetch(sectionName, optionName, variables);
}
return value;
}
public boolean hasOption(String sectionName, String optionName)
{
Ini.Section section = _ini.get(sectionName);
return (section != null) && section.containsKey(optionName);
}
public boolean hasSection(String sectionName)
{
return _ini.containsKey(sectionName);
}
@SuppressWarnings(Warnings.UNCHECKED)
public List> items(String sectionName) throws NoSectionException, InterpolationMissingOptionException
{
return items(sectionName, false, Collections.EMPTY_MAP);
}
@SuppressWarnings(Warnings.UNCHECKED)
public List> items(String sectionName, boolean raw) throws NoSectionException,
InterpolationMissingOptionException
{
return items(sectionName, raw, Collections.EMPTY_MAP);
}
public List> items(String sectionName, boolean raw, Map variables) throws NoSectionException,
InterpolationMissingOptionException
{
Ini.Section section = requireSection(sectionName);
Map ret;
if (raw)
{
ret = new HashMap(section);
}
else
{
ret = new HashMap();
for (String key : section.keySet())
{
ret.put(key, _ini.fetch(section, key, variables));
}
}
return new ArrayList>(ret.entrySet());
}
public List options(String sectionName) throws NoSectionException
{
requireSection(sectionName);
return new ArrayList(_ini.get(sectionName).keySet());
}
public void read(String... filenames) throws IOException, ParsingException
{
for (String filename : filenames)
{
read(new File(filename));
}
}
public void read(Reader reader) throws IOException, ParsingException
{
try
{
_ini.load(reader);
}
catch (InvalidFileFormatException x)
{
throw new ParsingException(x);
}
}
public void read(URL url) throws IOException, ParsingException
{
try
{
_ini.load(url);
}
catch (InvalidFileFormatException x)
{
throw new ParsingException(x);
}
}
public void read(File file) throws IOException, ParsingException
{
try
{
_ini.load(new FileReader(file));
}
catch (InvalidFileFormatException x)
{
throw new ParsingException(x);
}
}
public void read(InputStream stream) throws IOException, ParsingException
{
try
{
_ini.load(stream);
}
catch (InvalidFileFormatException x)
{
throw new ParsingException(x);
}
}
public boolean removeOption(String sectionName, String optionName) throws NoSectionException
{
Ini.Section section = requireSection(sectionName);
boolean ret = section.containsKey(optionName);
section.remove(optionName);
return ret;
}
public boolean removeSection(String sectionName)
{
boolean ret = _ini.containsKey(sectionName);
_ini.remove(sectionName);
return ret;
}
public List sections()
{
return new ArrayList(_ini.keySet());
}
public void set(String sectionName, String optionName, Object value) throws NoSectionException
{
Ini.Section section = requireSection(sectionName);
if (value == null)
{
section.remove(optionName);
}
else
{
section.put(optionName, value.toString());
}
}
public void write(Writer writer) throws IOException
{
_ini.store(writer);
}
public void write(OutputStream stream) throws IOException
{
_ini.store(stream);
}
public void write(File file) throws IOException
{
_ini.store(new FileWriter(file));
}
protected Ini getIni()
{
return _ini;
}
private String requireOption(String sectionName, String optionName) throws NoSectionException, NoOptionException
{
Ini.Section section = requireSection(sectionName);
String option = section.get(optionName);
if (option == null)
{
throw new NoOptionException(optionName);
}
return option;
}
private Ini.Section requireSection(String sectionName) throws NoSectionException
{
Ini.Section section = _ini.get(sectionName);
if (section == null)
{
throw new NoSectionException(sectionName);
}
return section;
}
public static class ConfigParserException extends Exception
{
/** Use serialVersionUID for interoperability. */ private static final long serialVersionUID = -6845546313519392093L;
public ConfigParserException(String message)
{
super(message);
}
}
public static final class DuplicateSectionException extends ConfigParserException
{
/** Use serialVersionUID for interoperability. */ private static final long serialVersionUID = -5244008445735700699L;
private DuplicateSectionException(String message)
{
super(message);
}
}
public static class InterpolationException extends ConfigParserException
{
/** Use serialVersionUID for interoperability. */ private static final long serialVersionUID = 8924443303158546939L;
protected InterpolationException(String message)
{
super(message);
}
}
public static final class InterpolationMissingOptionException extends InterpolationException
{
/** Use serialVersionUID for interoperability. */ private static final long serialVersionUID = 2903136975820447879L;
private InterpolationMissingOptionException(String message)
{
super(message);
}
}
public static final class NoOptionException extends ConfigParserException
{
/** Use serialVersionUID for interoperability. */ private static final long serialVersionUID = 8460082078809425858L;
private NoOptionException(String message)
{
super(message);
}
}
public static final class NoSectionException extends ConfigParserException
{
/** Use serialVersionUID for interoperability. */ private static final long serialVersionUID = 8553627727493146118L;
private NoSectionException(String message)
{
super(message);
}
}
public static final class ParsingException extends IOException
{
/** Use serialVersionUID for interoperability. */ private static final long serialVersionUID = -5395990242007205038L;
private ParsingException(Throwable cause)
{
super(cause.getMessage());
initCause(cause);
}
}
static class PyIni extends Ini
{
private static final char SUBST_CHAR = '%';
private static final Pattern EXPRESSION = Pattern.compile("(? _defaults;
private Ini.Section _defaultSection;
public PyIni(Map defaults)
{
_defaults = defaults;
Config cfg = getConfig().clone();
cfg.setEscape(false);
cfg.setMultiOption(false);
cfg.setMultiSection(false);
cfg.setLowerCaseOption(true);
cfg.setLowerCaseSection(true);
super.setConfig(cfg);
}
@Override public void setConfig(Config value)
{
assert true;
}
public Map getDefaults()
{
return _defaults;
}
@Override public Section add(String name)
{
Section section;
if (DEFAULT_SECTION_NAME.equalsIgnoreCase(name))
{
if (_defaultSection == null)
{
_defaultSection = newSection(name);
}
section = _defaultSection;
}
else
{
section = super.add(name);
}
return section;
}
public String fetch(String sectionName, String optionName, Map variables) throws InterpolationMissingOptionException
{
return fetch(get(sectionName), optionName, variables);
}
protected Ini.Section getDefaultSection()
{
return _defaultSection;
}
protected String fetch(Ini.Section section, String optionName, Map variables)
throws InterpolationMissingOptionException
{
String value = section.get(optionName);
if ((value != null) && (value.indexOf(SUBST_CHAR) >= 0))
{
StringBuilder buffer = new StringBuilder(value);
resolve(buffer, section, variables);
value = buffer.toString();
}
return value;
}
protected void resolve(StringBuilder buffer, Ini.Section owner, Map vars) throws InterpolationMissingOptionException
{
Matcher m = EXPRESSION.matcher(buffer);
while (m.find())
{
String optionName = m.group(G_OPTION);
String value = owner.get(optionName);
if (value == null)
{
value = vars.get(optionName);
}
if (value == null)
{
value = _defaults.get(optionName);
}
if ((value == null) && (_defaultSection != null))
{
value = _defaultSection.get(optionName);
}
if (value == null)
{
throw new InterpolationMissingOptionException(optionName);
}
buffer.replace(m.start(), m.end(), value);
m.reset(buffer);
}
}
@Override protected void store(IniHandler formatter)
{
formatter.startIni();
if (_defaultSection != null)
{
store(formatter, _defaultSection);
}
for (Ini.Section s : values())
{
store(formatter, s);
}
formatter.endIni();
}
@Override protected void store(IniHandler formatter, Section section)
{
formatter.startSection(section.getName());
for (String name : section.keySet())
{
formatter.handleOption(name, section.get(name));
}
formatter.endSection();
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy