Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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 java.io.File;
 import java.io.Reader;
 import java.io.Writer;
 
 import java.net.URL;
 
 import java.util.List;
 import java.util.Map;
 
 public class ConfigParser implements Serializable
 {
     private static final long serialVersionUID = 9118857036229164353L;
     private PyIni _ini;
 
     public ConfigParser()
     {
         this(.);
     }
 
     public ConfigParser(Map<StringStringdefaults)
     {
          = new PyIni(defaults);
     }
 
     public boolean getBoolean(String sectionString optionthrows NoSectionExceptionNoOptionExceptionInterpolationException
     {
         boolean ret;
         String value = get(sectionoption);
 
         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 sectionString optionthrows NoSectionExceptionNoOptionExceptionInterpolationException
     {
         return Double.parseDouble(get(sectionoption));
     }
 
     public float getFloat(String sectionString optionthrows NoSectionExceptionNoOptionExceptionInterpolationException
     {
         return Float.parseFloat(get(sectionoption));
     }
 
     public int getInt(String sectionString optionthrows NoSectionExceptionNoOptionExceptionInterpolationException
     {
         return Integer.parseInt(get(sectionoption));
     }
 
     public long getLong(String sectionString optionthrows NoSectionExceptionNoOptionExceptionInterpolationException
     {
         return Long.parseLong(get(sectionoption));
     }
 
     public void addSection(String sectionthrows DuplicateSectionException
    {
        if (.containsKey(section))
        {
            throw new DuplicateSectionException(section);
        }
        else if (..equalsIgnoreCase(section))
        {
            throw new IllegalArgumentException(section);
        }
        .add(section);
    }
    public Map<StringStringdefaults()
    {
        return .getDefaults();
    }
    public String get(String sectionString optionthrows NoSectionExceptionNoOptionExceptionInterpolationException
    {
        return get(sectionoptionfalse.);
    }
    public String get(String sectionString optionboolean rawthrows NoSectionExceptionNoOptionExceptionInterpolationException
    {
        return get(sectionoptionraw.);
    }
    public String get(String sectionNameString optionNameboolean rawMap<StringStringvariablesthrows NoSectionException,
    {
        String value = requireOption(sectionNameoptionName);
        if (!raw && (value != null) && (value.indexOf(.) >= 0))
        {
            value = .fetch(sectionNameoptionNamevariables);
        }
        return value;
    }
    public boolean hasOption(String sectionNameString optionName)
    {
        Ini.Section section = .get(sectionName);
        return (section != null) && section.containsKey(optionName);
    }
    public boolean hasSection(String sectionName)
    {
        return .containsKey(sectionName);
    }
    {
        return items(sectionNamefalse.);
    }
    public List<Map.Entry<StringString>> items(String sectionNameboolean rawthrows NoSectionException,
    {
        return items(sectionNameraw.);
    }
    public List<Map.Entry<StringString>> items(String sectionNameboolean rawMap<StringStringvariablesthrows NoSectionException,
    {
        Ini.Section section = requireSection(sectionName);
        Map<StringStringret;
        if (raw)
        {
            ret = new HashMap<StringString>(section);
        }
        else
        {
            ret = new HashMap<StringString>();
            for (String key : section.keySet())
            {
                ret.put(key.fetch(sectionkeyvariables));
            }
        }
        return new ArrayList<Map.Entry<StringString>>(ret.entrySet());
    }
    public List<Stringoptions(String sectionNamethrows NoSectionException
    {
        requireSection(sectionName);
        return new ArrayList<String>(.get(sectionName).keySet());
    }
    public void read(String... filenamesthrows IOExceptionParsingException
    {
        for (String filename : filenames)
        {
            read(new File(filename));
        }
    }
    public void read(Reader readerthrows IOExceptionParsingException
    {
        try
        {
            .load(reader);
        }
        catch (InvalidFileFormatException x)
        {
            throw new ParsingException(x);
        }
    }
    public void read(URL urlthrows IOExceptionParsingException
    {
        try
        {
            .load(url);
        }
        catch (InvalidFileFormatException x)
        {
            throw new ParsingException(x);
        }
    }
    public void read(File filethrows IOExceptionParsingException
    {
        try
        {
            .load(new FileReader(file));
        }
        catch (InvalidFileFormatException x)
        {
            throw new ParsingException(x);
        }
    }
    public void read(InputStream streamthrows IOExceptionParsingException
    {
        try
        {
            .load(stream);
        }
        catch (InvalidFileFormatException x)
        {
            throw new ParsingException(x);
        }
    }
    public boolean removeOption(String sectionNameString optionNamethrows NoSectionException
    {
        Ini.Section section = requireSection(sectionName);
        boolean ret = section.containsKey(optionName);
        section.remove(optionName);
        return ret;
    }
    public boolean removeSection(String sectionName)
    {
        boolean ret = .containsKey(sectionName);
        .remove(sectionName);
        return ret;
    }
    public List<Stringsections()
    {
        return new ArrayList<String>(.keySet());
    }
    public void set(String sectionNameString optionNameObject valuethrows NoSectionException
    {
        Ini.Section section = requireSection(sectionName);
        if (value == null)
        {
            section.remove(optionName);
        }
        else
        {
            section.put(optionNamevalue.toString());
        }
    }
    public void write(Writer writerthrows IOException
    {
        .store(writer);
    }
    public void write(OutputStream streamthrows IOException
    {
        .store(stream);
    }
    public void write(File filethrows IOException
    {
        .store(new FileWriter(file));
    }
    protected Ini getIni()
    {
        return ;
    }
    private String requireOption(String sectionNameString optionNamethrows NoSectionExceptionNoOptionException
    {
        Ini.Section section = requireSection(sectionName);
        String option = section.get(optionName);
        if (option == null)
        {
            throw new NoOptionException(optionName);
        }
        return option;
    }
    private Ini.Section requireSection(String sectionNamethrows NoSectionException
    {
        Ini.Section section = .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("(?<!\\\\)\\%\\(([^\\)]+)\\)");
        private static final int G_OPTION = 1;
        protected static final String DEFAULT_SECTION_NAME = "DEFAULT";
        private static final long serialVersionUID = -7152857626328996122L;
        private final Map<StringString_defaults;
        private Ini.Section _defaultSection;
        public PyIni(Map<StringStringdefaults)
        {
             = 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<StringStringgetDefaults()
        {
            return ;
        }
        @Override public Section add(String name)
        {
            Section section;
            if (.equalsIgnoreCase(name))
            {
                if ( == null)
                {
                     = newSection(name);
                }
                section = ;
            }
            else
            {
                section = super.add(name);
            }
            return section;
        }
        public String fetch(String sectionNameString optionNameMap<StringStringvariablesthrows InterpolationMissingOptionException
        {
            return fetch(get(sectionName), optionNamevariables);
        }
        protected Ini.Section getDefaultSection()
        {
            return ;
        }
        protected String fetch(Ini.Section sectionString optionNameMap<StringStringvariables)
            throws InterpolationMissingOptionException
        {
            String value = section.get(optionName);
            if ((value != null) && (value.indexOf() >= 0))
            {
                StringBuilder buffer = new StringBuilder(value);
                resolve(buffersectionvariables);
                value = buffer.toString();
            }
            return value;
        }
        protected void resolve(StringBuilder bufferIni.Section ownerMap<StringStringvarsthrows InterpolationMissingOptionException
        {
            Matcher m = .matcher(buffer);
            while (m.find())
            {
                String optionName = m.group();
                String value = owner.get(optionName);
                if (value == null)
                {
                    value = vars.get(optionName);
                }
                if (value == null)
                {
                    value = .get(optionName);
                }
                if ((value == null) && ( != null))
                {
                    value = .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 ( != null)
            {
                store(formatter);
            }
            for (Ini.Section s : values())
            {
                store(formatters);
            }
            formatter.endIni();
        }
        @Override protected void store(IniHandler formatterSection section)
        {
            formatter.startSection(section.getName());
            for (String name : section.keySet())
            {
                formatter.handleOption(namesection.get(name));
            }
            formatter.endSection();
        }
    }
New to GrepCode? Check out our FAQ X