protected void verifyElement(ConfigElement element) { Preconditions.checkNotNull(element); Preconditions.checkArgument(element.getRoot().equals(root),"Configuration element is not associated with this configuration: %s",element); }
@SuppressWarnings("unchecked") private <E> List<E> getSortedChildren(ConfigNamespace n, Function<ConfigElement, Boolean> predicate) { final List<ConfigElement> sortedElements = new ArrayList<>(); for (ConfigElement e : n.getChildren()) { if (predicate.apply(e)) { sortedElements.add(e); } } sortedElements.sort(Comparator.comparing(ConfigElement::getName)); return (List<E>)sortedElements; }
private String getNamespaceSectionHeader(ConfigNamespace n, String prefix) { String fullName = prefix + n.getName(); if (n.isUmbrella()) fullName += " *"; return "==== " + fullName + " ====\n[role=\"font16\"]\n" + n.getDescription() + "\n\n"; }
/** * Whether this namespace or any parent namespace is an umbrella namespace. * @return */ public boolean hasUmbrella() { return isUmbrella() || (!isRoot() && getNamespace().hasUmbrella()); }
private String getFullPath(ConfigOption<?> opt) { StringBuilder sb = new StringBuilder(64); sb.insert(0, opt.getName()); for (ConfigNamespace parent = opt.getNamespace(); null != parent && !parent.isRoot(); parent = parent.getNamespace()) { if (parent.isUmbrella()) sb.insert(0, "[X]."); sb.insert(0, "."); sb.insert(0, parent.getName()); } return sb.toString(); }
private void printNamespace(ConfigNamespace n, String prefix) { String newPrefix = prefix + n.getName() + "."; if (n.isUmbrella()) newPrefix += "[X]."; if (n.isRoot()) newPrefix = ""; //Override for root namespace //Only print namespace if it contains (visible) options if (!Iterables.isEmpty(getSortedChildOptions(n))) { stream.println(getNamespaceSectionHeader(n, prefix)); stream.println(getTableHeader()); for (ConfigOption<?> o : getSortedChildOptions(n)) { stream.println(getTableLineForOption(o, newPrefix)); } stream.println(TABLE_FOOTER_LINES); } for (ConfigNamespace cn : getSortedChildNamespaces(n)) { printNamespace(cn, newPrefix); } }
public static PathIdentifier parse(ConfigNamespace root, String path) { Preconditions.checkNotNull(root); if (StringUtils.isBlank(path)) return new PathIdentifier(root,new String[]{},false); String[] components = getComponents(path); Preconditions.checkArgument(components.length>0,"Empty path provided: %s",path); List<String> umbrellaElements = Lists.newArrayList(); ConfigNamespace parent = root; ConfigElement last = root; boolean lastIsUmbrella = false; for (int i=0;i<components.length;i++) { if (parent.isUmbrella() && !lastIsUmbrella) { umbrellaElements.add(components[i]); lastIsUmbrella = true; } else { last = parent.getChild(components[i]); Preconditions.checkArgument(last!=null,"Unknown configuration element in namespace [%s]: %s",parent.toString(),components[i]); if (i+1<components.length) { Preconditions.checkArgument(last instanceof ConfigNamespace,"Expected namespace at position [%s] of [%s] but got: %s",i,path,last); parent = (ConfigNamespace)last; } lastIsUmbrella = false; } } return new PathIdentifier(last,umbrellaElements.toArray(new String[umbrellaElements.size()]), lastIsUmbrella); }
protected AbstractConfiguration(ConfigNamespace root) { Preconditions.checkNotNull(root); Preconditions.checkArgument(!root.isUmbrella(),"Root cannot be an umbrella namespace"); this.root = root; }
@Override public boolean has(ConfigOption option, String... umbrellaElements) { if (option.getNamespace().hasUmbrella()) return config.has(option,concat(umbrellaElements)); else return config.has(option); }
protected Map<String,Object> getSubset(ReadConfiguration config, ConfigNamespace umbrella, String... umbrellaElements) { verifyElement(umbrella); String prefix = umbrella.isRoot() ? "" : ConfigElement.getPath(umbrella, umbrellaElements); Map<String,Object> result = Maps.newHashMap(); for (String key : config.getKeys(prefix)) { Preconditions.checkArgument(key.startsWith(prefix)); // A zero-length prefix is a root. A positive-length prefix // is not a root and we should tack on an additional character // to consume the dot between the prefix and the rest of the key. int startIndex = umbrella.isRoot() ? prefix.length() : prefix.length() + 1; String sub = key.substring(startIndex).trim(); if (!sub.isEmpty()) { result.put(sub,config.get(key,Object.class)); } } return result; }
public ConfigNamespace getRoot() { if (isRoot()) return (ConfigNamespace)this; else return getNamespace().getRoot(); }
Pattern.quote(STORAGE_NS.getName()) + "\\..*" + "(" + Pattern.quote(STORAGE_DIRECTORY.getName()) + "|" + Pattern.quote(STORAGE_CONF_FILE.getName()) + ")" + "|" + Pattern.quote(INDEX_NS.getName()) + "\\..*" + "(" + Pattern.quote(INDEX_DIRECTORY.getName()) + "|" + Pattern.quote(INDEX_CONF_FILE.getName()) + ")"
public static String getPath(ConfigElement element, boolean includeRoot, String... umbrellaElements) { Preconditions.checkNotNull(element); if (umbrellaElements==null) umbrellaElements = new String[0]; StringBuilder path = new StringBuilder(element.getName()); int umbrellaPos = umbrellaElements.length-1; while (!element.isRoot() && !element.getNamespace().isRoot()) { ConfigNamespace parent = element.getNamespace(); if (parent.isUmbrella()) { Preconditions.checkArgument(umbrellaPos>=0,"Missing umbrella element path for element: %s",element); String umbrellaName = umbrellaElements[umbrellaPos]; Preconditions.checkArgument(!StringUtils.containsAny(umbrellaName,ILLEGAL_CHARS),"Invalid umbrella name provided: %s. Contains illegal chars",umbrellaName); path.insert(0, umbrellaName + SEPARATOR); umbrellaPos--; } path.insert(0, parent.getName() + SEPARATOR); element = parent; } if (includeRoot) { // Assumes that roots are not umbrellas // If roots could be umbrellas, we might have to change the interpretation of umbrellaElements path.insert(0, (element.isRoot() ? element.getName() : element.getNamespace().getName()) + SEPARATOR); } //Don't make this check so that we can still access more general config items Preconditions.checkArgument(umbrellaPos<0,"Found unused umbrella element: %s",umbrellaPos<0?null:umbrellaElements[umbrellaPos]); return path.toString(); }
protected Set<String> getContainedNamespaces(ReadConfiguration config, ConfigNamespace umbrella, String... umbrellaElements) { verifyElement(umbrella); Preconditions.checkArgument(umbrella.isUmbrella()); String prefix = ConfigElement.getPath(umbrella,umbrellaElements); Set<String> result = Sets.newHashSet(); for (String key : config.getKeys(prefix)) { Preconditions.checkArgument(key.startsWith(prefix)); String sub = key.substring(prefix.length()+1).trim(); if (!sub.isEmpty()) { String ns = ConfigElement.getComponents(sub)[0]; Preconditions.checkArgument(StringUtils.isNotBlank(ns),"Invalid sub-namespace for key: %s",key); result.add(ns); } } return result; }
@Override public <O> O get(ConfigOption<O> option, String... umbrellaElements) { if (option.getNamespace().hasUmbrella()) return config.get(option,concat(umbrellaElements)); else return config.get(option); }
ConfigNamespace ns = (ConfigNamespace)pp.element; StringBuilder s = new StringBuilder(); if (ns.isUmbrella() && !pp.lastIsUmbrella) { for (String sub : config.getContainedNamespaces(ns,pp.umbrellaElements)) { s.append("+ ").append(sub).append("\n");
public static String toString(ConfigElement element) { String result = element.getName(); if (element.isNamespace()) { result = "+ " + result; if (((ConfigNamespace)element).isUmbrella()) result += " [*]"; } else { result = "- " + result; ConfigOption option = (ConfigOption)element; result+= " ["; switch (option.getType()) { case FIXED: result+="f"; break; case GLOBAL_OFFLINE: result+="g!"; break; case GLOBAL: result+="g"; break; case MASKABLE: result+="m"; break; case LOCAL: result+="l"; break; } result+=","+option.getDatatype().getSimpleName(); result+=","+option.getDefaultValue(); result+="]"; } result = result + "\n"; String desc = element.getDescription(); result+="\t"+'"'+desc.substring(0, Math.min(desc.length(), 50))+'"'; return result; }