com.electronwill.nightconfig.hocon.HoconParser Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of hocon Show documentation
Powerful, easy-to-use and multi-language configuration library for the JVM - hocon module
The newest version!
package com.electronwill.nightconfig.hocon;

import com.electronwill.nightconfig.core.CommentedConfig;
import com.electronwill.nightconfig.core.Config;
import com.electronwill.nightconfig.core.ConfigFormat;
import com.electronwill.nightconfig.core.concurrent.ConcurrentCommentedConfig;
import com.electronwill.nightconfig.core.io.ConfigParser;
import com.electronwill.nightconfig.core.io.ParsingException;
import com.electronwill.nightconfig.core.io.ParsingMode;
import com.typesafe.config.*;

import java.io.Reader;
import java.util.*;

import static com.electronwill.nightconfig.core.NullObject.NULL_OBJECT;

/**
 * A HOCON parser that uses the typesafehub config library.
 *
 * @author TheElectronWill
 * @see HOCON spec by
 * typesafehub
 */
public final class HoconParser implements ConfigParser {
	private static final ConfigParseOptions OPTIONS = ConfigParseOptions.defaults()
																		.setAllowMissing(false)
																		.setSyntax(ConfigSyntax.CONF);

	@Override
	public ConfigFormat getFormat() {
		return HoconFormat.instance();
	}

	@Override
	public CommentedConfig parse(Reader reader) {
		CommentedConfig config = HoconFormat.instance().createConfig();
		parse(reader, config, ParsingMode.MERGE);
		return config;
	}

	@Override
	public void parse(Reader reader, Config destination, ParsingMode parsingMode) {
		try {
			ConfigObject parsed = ConfigFactory.parseReader(reader, OPTIONS).resolve().root();

			if (destination instanceof ConcurrentCommentedConfig) {
				ConcurrentCommentedConfig conf = (ConcurrentCommentedConfig)destination;
				conf.bulkCommentedUpdate(view -> {
					parsingMode.prepareParsing(view);
					put(parsed, view, parsingMode);
				});
			} else if (destination instanceof CommentedConfig) {
				parsingMode.prepareParsing(destination);
				put(parsed, (CommentedConfig)destination, parsingMode);
			} else {
				parsingMode.prepareParsing(destination);
				put(parsed, destination, parsingMode);
			}
		} catch (Exception e) {
			throw new ParsingException("HOCON parsing failed", e);
		}
	}

	private static void put(ConfigObject typesafeConfig, Config destination,
							ParsingMode parsingMode) {
		for (Map.Entry entry : typesafeConfig.entrySet()) {
			List path = ConfigUtil.splitPath(entry.getKey());
			parsingMode.put(destination, path, unwrap(entry.getValue().unwrapped()));
		}
	}

	private static void put(ConfigObject typesafeConfig, CommentedConfig destination,
							ParsingMode parsingMode) {
		for (Map.Entry entry : typesafeConfig.entrySet()) {
			List path = Collections.singletonList(entry.getKey());
			ConfigValue value = entry.getValue();
			if (value instanceof ConfigObject) {
				CommentedConfig subConfig = destination.createSubConfig();
				put((ConfigObject)value, subConfig, parsingMode);
				parsingMode.put(destination, path, subConfig);
			} else {
				parsingMode.put(destination, path, unwrap(value.unwrapped()));
			}
			List comments = value.origin().comments();
			if (!comments.isEmpty()) {
				destination.setComment(path, String.join("\n", value.origin().comments()));
			}
		}
	}

	@SuppressWarnings("unchecked")
	private static Object unwrap(Object o) {
		if (o instanceof Map) {
			Map map = (Map)o;
			Map unwrappedMap = new HashMap<>(map.size());
			for (Map.Entry entry : map.entrySet()) {
				unwrappedMap.put(entry.getKey(), unwrap(entry.getValue()));
			}
			return Config.wrap(unwrappedMap, HoconFormat.instance());
		} else if (o instanceof List) {
			List list = (List)o;
			if (!list.isEmpty() && list.get(0) instanceof Map) {
				List configList = new ArrayList<>();
				for (Object element : list) {
					configList.add((Config)unwrap(element));
				}
				return configList;
			}
		} else if (o == null) {
			return NULL_OBJECT;
		}
		return o;
	}
}