/** * Checks whether an option exists in a given section. Options in the * common section are assumed to not exist in particular sections, * unless they're overwritten. * * @param section the section's name * @param option the option's name * @return true if the given section has the option */ public boolean hasOption(String section, String option) { return hasSection(section) && getSection(section).hasOption(option); }
/** * Loads INI formatted input from a file into this instance, using the * default character encoding. Everything in the file before the first * section header is ignored. * * @param filename file to read from * @throws IOException at an I/O problem */ public void load(String filename) throws IOException { load(new File(filename)); }
/** * Returns a section by name or <code>null</code> if not found. * * @param name the section's name * @return the section */ private Section getSection(String name) { return (Section) sections.get(normSection(name)); }
/** * Removes a section if it exists. * * @param name the section's name * @return <code>true</code> if the section actually existed * @throws IllegalArgumentException when trying to remove the common section */ public boolean removeSection(String name) { String normName = normSection(name); if (this.commonName != null && this.commonName.equals(normName)) { throw new IllegalArgumentException("Can't remove common section"); } if (hasSection(normName)) { this.sections.remove(normName); this.sectionOrder.remove(normName); return true; } else { return false; } }
/** * Loads INI formatted input from a stream reader into this instance. * Everything in the stream before the first section header is ignored. * * @param streamReader where to read from * @throws IOException at an I/O problem */ public void load(InputStreamReader streamReader) throws IOException { BufferedReader reader = new BufferedReader(streamReader); String curSection = null; String line = null; while (reader.ready()) { line = reader.readLine().trim(); if (line.length() > 0 && line.charAt(0) == Section.HEADER_START) { int endIndex = line.indexOf(Section.HEADER_END); if (endIndex >= 0) { curSection = line.substring(1, endIndex); addSection(curSection); } } if (curSection != null) { Section sect = getSection(curSection); sect.load(reader); } } }
/** * Writes this instance in INI format to a file. * * @param filename the file to write to * @throws IOException at an I/O problem */ public void save(String filename) throws IOException { save(new File(filename)); }
/** * Writes this instance in INI format to an output stream writer. * * @param streamWriter where to write * @throws IOException at an I/O problem */ public void save(OutputStreamWriter streamWriter) throws IOException { Iterator<String> it = this.sectionOrder.iterator(); PrintWriter writer = new PrintWriter(streamWriter, true); while (it.hasNext()) { Section sect = getSection((String) it.next()); writer.println(sect.header()); sect.save(writer); } }
/** * Constructs new IniEditor instance with a common section, defining * comment delimiters. Options in the common section are used as defaults * for all other sections. * * @param commonName name of the common section * @param delims an array of characters to be recognized as starters of * comment lines; the first of them will be used for newly created * comments */ public IniEditor(String commonName, char[] delims, boolean isCaseSensitive) { this.sections = new HashMap<String, Section>(); this.sectionOrder = new LinkedList<String>(); this.isCaseSensitive = isCaseSensitive; if (commonName != null) { this.commonName = commonName; addSection(this.commonName); } this.commentDelims = delims; this.optionFormat = new OptionFormat(Section.DEFAULT_OPTION_FORMAT); }
/** * Adds a section if it doesn't exist yet. * * @param name the name of the section * @return <code>true</code> if the section didn't already exist * @throws IllegalArgumentException the name is illegal, ie contains one * of the characters '[' and ']' or consists only of white space */ public boolean addSection(String name) { String normName = normSection(name); if (!hasSection(normName)) { // Section constructor might throw IllegalArgumentException Section section = new Section(normName, this.commentDelims, this.isCaseSensitive); section.setOptionFormat(this.optionFormat); this.sections.put(normName, section); this.sectionOrder.add(normName); return true; } else { return false; } }
/** * Writes this instance in INI format to an output stream. This method * takes an <code>OutputStream</code> for maximum flexibility, internally * it does of course use a writer for character based output. * * @param stream where to write * @throws IOException at an I/O problem */ public void save(OutputStream stream) throws IOException { save(new OutputStreamWriter(stream)); }
/** * Adds a blank line to the end of a section. * * @param section the section's name * @throws IniEditor.NoSuchSectionException no section with the given name exists */ public void addBlankLine(String section) { if (hasSection(section)) { getSection(section).addBlankLine(); } else { throw new NoSuchSectionException(section); } }
/** * Writes this instance in INI format to a file. * * @param file where to save to * @throws IOException at an I/O problem */ public void save(File file) throws IOException { OutputStream out = new FileOutputStream(file); save(out); out.close(); }
/** * Loads INI formatted input from a stream into this instance, using the * default character encoding. This method takes an <code>InputStream</code> * for maximum flexibility, internally it does use a reader (using the * default character encoding) for character based input. Everything in the * stream before the first section header is ignored. * * @param stream where to read from * @throws IOException at an I/O problem */ public void load(InputStream stream) throws IOException { load(new InputStreamReader(stream)); }
/** * Checks whether a section with a particular name exists in this instance. * * @param name the name of the section * @return true if the section exists */ public boolean hasSection(String name) { return this.sections.containsKey(normSection(name)); }
/** * Removes an option from a section if it exists. Will not remove options * from the common section if it's not directly addressed. * * @param section the section's name * @param option the option's name * @return <code>true</code> if the option was actually removed * @throws IniEditor.NoSuchSectionException no section with the given name exists */ public boolean remove(String section, String option) { if (hasSection(section)) { return getSection(section).remove(option); } else { throw new NoSuchSectionException(section); } }
/** * Loads INI formatted input from a file into this instance, using the * default character encoding. Everything in the file before the first * section header is ignored. * * @param file file to read from * @throws IOException at an I/O problem */ public void load(File file) throws IOException { InputStream in = new FileInputStream(file); load(in); in.close(); }
/** * Returns all option names of a section, not including options from the * common section. * * @param section the section's name * @return list of option names * @throws IniEditor.NoSuchSectionException no section with the given name exists */ public List<String> optionNames(String section) { if (hasSection(section)) { return getSection(section).optionNames(); } else { throw new NoSuchSectionException(section); } }
/** * Adds a comment line to the end of a section. A comment spanning * several lines (ie with line breaks) will be split up, one comment * line for each line. * * @param section the section's name * @param comment the comment * @throws IniEditor.NoSuchSectionException no section with the given name exists */ public void addComment(String section, String comment) { if (hasSection(section)) { getSection(section).addComment(comment); } else { throw new NoSuchSectionException(section); } }
/** * Sets the value of an option in a section, if the option exist, otherwise * adds the option to the section. Trims white space from the start and the * end of the value and deletes newline characters it might contain. * * @param section the section's name * @param option the option's name * @param value the option's value * @throws IniEditor.NoSuchSectionException no section with the given name exists * @throws IllegalArgumentException the option name is illegal, * ie contains a '=' character or consists only of white space * @throws NullPointerException section or option are <code>null</code> */ public void set(String section, String option, String value) { if (hasSection(section)) { getSection(section).set(option, value); } else { throw new NoSuchSectionException(section); } }
/** * Returns the value of a given option in a given section or null if either * the section or the option don't exist. If a common section was defined * options are also looked up there if they're not present in the specific * section. * * @param section the section's name * @param option the option's name * @return the option's value * @throws NullPointerException any of the arguments is <code>null</code> */ public String get(String section, String option) { if (hasSection(section)) { Section sect = getSection(section); if (sect.hasOption(option)) { return sect.get(option); } if (this.commonName != null) { return getSection(this.commonName).get(option); } } return null; }