private static ConfigKey<?> createConfigKeyFromInstance(Class<?> configInstClass, String configId) { try { String defName = ConfigInstance.getDefName(configInstClass); String defNamespace = ConfigInstance.getDefNamespace(configInstClass); return new ConfigKey<>(defName, configId, defNamespace); } catch (IllegalArgumentException | SecurityException e) { throw new RuntimeException(e); } }
/** * Gets the name of the given config instance */ public static String getDefName(Class<?> type) { return getStaticStringField(type, "CONFIG_DEF_NAME"); }
private static void serializeMap(Map<String, Object> childMap, Serializer serializer) { for (Map.Entry<String, Object> entry : childMap.entrySet()) { String name = entry.getKey(); Object child = entry.getValue(); serializeObject(name, child, serializer); } }
@SuppressWarnings("unchecked") private static void serializeObject(String name, Object child, Serializer serializer) { if (child instanceof InnerNode) { Serializer childSerializer = serializer.createInner(name); serialize((InnerNode) child, childSerializer); } else if (child instanceof Map) { Serializer mapSerializer = serializer.createMap(name); serializeMap((Map<String, Object>)child, mapSerializer); } else if (child instanceof NodeVector) { Serializer arraySerializer = serializer.createArray(name); serializeArray((NodeVector) child, arraySerializer); } else if (child instanceof LeafNode) { ((LeafNode) child).serialize(name, serializer); } }
@Override public String toString() { return mkString(ConfigInstance.serialize(this), "\n"); }
private void writeBuilder(File directory, Method m, ConfigInstance.Builder builder) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException, IOException { m.invoke(this, builder); Class<?> configInstClass = builder.getClass().getEnclosingClass(); ConfigInstance inst = (ConfigInstance) configInstClass.getConstructor(builder.getClass()).newInstance(builder); List<String> payloadList = ConfigInstance.serialize(inst); File outfn = new File(directory, ConfigInstance.getDefName(inst.getClass()) + ".MODEL.cfg"); FileOutputStream out = new FileOutputStream(outfn); for (String s : payloadList) { out.write(Utf8.toBytes(s)); out.write('\n'); } }
/** * Returns the serialized representation of the given node. * <p> * Declared static, instead of InnerNode member, to avoid a public 0-arg method with a commonly used name. * * @param node The inner node * @return a list of strings, containing the serialized representation of this config */ public static List<String> serialize(InnerNode node) { List<String> ret = new ArrayList<>(); for (Map.Entry<String, LeafNode<?>> entry : getAllDescendantLeafNodes(node).entrySet()) { ret.add(entry.getKey() + " " + entry.getValue().toString()); } return ret; }
public static void serialize(InnerNode node, Serializer serializer) { serializeMap(node.getChildren(), serializer); }
private static void exportCfg(ConfigInstance instance, String fileName) throws IOException { Writer writer = null; try { writer = IOUtils.createWriter(fileName, false); if (writer != null) { writer.write(instance.toString()); writer.write("\n"); } } finally { if (writer != null) { IOUtils.closeWriter(writer); } } }
/** * Checks what this is a producer of, instantiate that and export to writer */ // TODO move to ReflectionUtil, and move that to unexported pkg private void exportBuilderConfig(Writer writer) throws ReflectiveOperationException, SecurityException, IllegalArgumentException, IOException { for (Class<?> intf : getClass().getInterfaces()) { if (ConfigInstance.Producer.class.isAssignableFrom(intf)) { Class<?> configClass = intf.getEnclosingClass(); String builderClassName = configClass.getCanonicalName()+"$Builder"; Class<?> builderClass = Class.forName(builderClassName); ConfigInstance.Builder builder = (Builder) builderClass.getDeclaredConstructor().newInstance(); Method getConfig = getClass().getMethod("getConfig", builderClass); getConfig.invoke(this, builder); ConfigInstance inst = (ConfigInstance) configClass.getConstructor(builderClass).newInstance(builder); List<String> payloadL = ConfigInstance.serialize(inst); String payload = StringUtilities.implodeMultiline(payloadL); writer.write(payload); } } }
private static void serializeArray(NodeVector<?> nodeVector, Serializer arraySerializer) { for (Object child : nodeVector.vector) { if (child instanceof InnerNode) { Serializer childSerializer = arraySerializer.createInner(); serialize((InnerNode) child, childSerializer); } else if (child instanceof LeafNode) { ((LeafNode) child).serialize(arraySerializer); } } }
/** * Gets the namespace of the given config instance */ public static String getDefNamespace(Class<?> type) { return getStaticStringField(type, "CONFIG_DEF_NAMESPACE"); }
private static void writeConfig(String dir, String configName, ConfigInstance config) throws IOException { IOUtils.writeFile(dir + configName, StringUtilities.implodeMultiline(ConfigInstance.serialize(config)), false); }