You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sling.apache.org by ra...@apache.org on 2019/12/02 11:01:19 UTC
[sling-org-apache-sling-scripting-sightly-runtime] branch master
updated: SLING-8865 - Enhance the HTL runtime and script engine to take
advantage of the support for lazy bindings
This is an automated email from the ASF dual-hosted git repository.
radu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-scripting-sightly-runtime.git
The following commit(s) were added to refs/heads/master by this push:
new 9bd5900 SLING-8865 - Enhance the HTL runtime and script engine to take advantage of the support for lazy bindings
9bd5900 is described below
commit 9bd5900804b06832abe1913b14a6b8ff6dab2489
Author: Radu Cotescu <17...@users.noreply.github.com>
AuthorDate: Mon Dec 2 12:01:12 2019 +0100
SLING-8865 - Enhance the HTL runtime and script engine to take advantage of the support for lazy bindings
* made the CaseInsensitiveBindings more efficient by working with key copies and wrapping the
original bindings map; if the original bindings map is a LazyBindings instance, extending it
with support for case insensitive keys will not expand all the Suppliers
---
.../sling/scripting/sightly/render/RenderUnit.java | 98 +++++++++++++++++++---
1 file changed, 87 insertions(+), 11 deletions(-)
diff --git a/src/main/java/org/apache/sling/scripting/sightly/render/RenderUnit.java b/src/main/java/org/apache/sling/scripting/sightly/render/RenderUnit.java
index 617565f..23c0cb8 100644
--- a/src/main/java/org/apache/sling/scripting/sightly/render/RenderUnit.java
+++ b/src/main/java/org/apache/sling/scripting/sightly/render/RenderUnit.java
@@ -19,8 +19,11 @@
package org.apache.sling.scripting.sightly.render;
import java.io.PrintWriter;
+import java.util.AbstractMap;
+import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Map;
import java.util.Set;
@@ -103,13 +106,12 @@ public abstract class RenderUnit implements Record<RenderUnit> {
}
private Bindings buildGlobalScope(Bindings bindings) {
- SimpleBindings simpleBindings = new SimpleBindings(bindings);
- simpleBindings.putAll(bindings);
+ CaseInsensitiveBindings caseInsensitiveBindings = new CaseInsensitiveBindings(bindings);
if (siblings != null) {
- simpleBindings.putAll(siblings);
+ caseInsensitiveBindings.putAll(siblings);
}
- simpleBindings.putAll(subTemplates);
- return new CaseInsensitiveBindings(simpleBindings);
+ caseInsensitiveBindings.putAll(subTemplates);
+ return caseInsensitiveBindings;
}
protected static class FluentMap extends HashMap<String, Object> {
@@ -128,11 +130,16 @@ public abstract class RenderUnit implements Record<RenderUnit> {
}
- private static final class CaseInsensitiveBindings extends SimpleBindings {
+ private static final class CaseInsensitiveBindings implements Bindings {
- private CaseInsensitiveBindings(Map<String, Object> m) {
- for (Entry<String, Object> entry : m.entrySet()) {
- put(entry.getKey().toLowerCase(), entry.getValue());
+ private final Map<String, Object> wrapped;
+ private final Map<String, String> keyMappings;
+
+ private CaseInsensitiveBindings(Map<String, Object> wrapped) {
+ this.wrapped = wrapped;
+ keyMappings = new HashMap<>();
+ for (String key : this.wrapped.keySet()) {
+ keyMappings.put(key.toLowerCase(), key);
}
}
@@ -141,7 +148,11 @@ public abstract class RenderUnit implements Record<RenderUnit> {
if (!(key instanceof String)) {
throw new ClassCastException("key should be a String");
}
- return super.get(((String) key).toLowerCase());
+ String mappedKey = keyMappings.get(((String) key).toLowerCase());
+ if (mappedKey != null) {
+ return wrapped.get(mappedKey);
+ }
+ return null;
}
@Override
@@ -149,7 +160,72 @@ public abstract class RenderUnit implements Record<RenderUnit> {
if (!(key instanceof String)) {
throw new ClassCastException("key should be a String");
}
- return super.containsKey(((String) key).toLowerCase());
+ return keyMappings.containsKey(((String) key).toLowerCase());
+ }
+
+ @Override
+ public Object put(String key, Object value) {
+ keyMappings.put(key.toLowerCase(), key);
+ return wrapped.put(key, value);
+ }
+
+ @Override
+ public void putAll(Map<? extends String, ?> toMerge) {
+ for (Map.Entry<? extends String, ?> entry : toMerge.entrySet()) {
+ put(entry.getKey(), entry.getValue());
+ }
+ }
+
+ @Override
+ public Object remove(Object key) {
+ if (!(key instanceof String)) {
+ throw new ClassCastException("key should be a String");
+ }
+ String originalKey = keyMappings.remove(((String) key).toLowerCase());
+ if (originalKey != null) {
+ return wrapped.remove(originalKey);
+ }
+ return null;
+ }
+
+ @Override
+ public int size() {
+ return wrapped.size();
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return wrapped.isEmpty();
+ }
+
+ @Override
+ public boolean containsValue(Object value) {
+ return wrapped.containsValue(value);
+ }
+
+ @Override
+ public void clear() {
+ wrapped.clear();
+ keyMappings.clear();
+ }
+
+ @Override
+ public Set<String> keySet() {
+ return keyMappings.keySet();
+ }
+
+ @Override
+ public Collection<Object> values() {
+ return wrapped.values();
+ }
+
+ @Override
+ public Set<Entry<String, Object>> entrySet() {
+ Set<Entry<String, Object>> entrySet = new HashSet<>();
+ for (Map.Entry<String, String> entry : keyMappings.entrySet()) {
+ entrySet.add(new AbstractMap.SimpleEntry<>(entry.getKey(), wrapped.get(entry.getValue())));
+ }
+ return entrySet;
}
}