add back needed methods

Author: Joe Alphonso

core/utils/accumulo-utils/src/main/java/datawave/marking/ColumnVisibilityCache.java

@@ -0,0 +1,22 @@
+package datawave.marking;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.apache.accumulo.core.data.ByteSequence;
+import org.apache.accumulo.core.security.ColumnVisibility;
+import org.apache.commons.collections4.map.LRUMap;
+
+public class ColumnVisibilityCache {
+    @SuppressWarnings("unchecked")
+    private static Map<ByteSequence,ColumnVisibility> cache = Collections.synchronizedMap(new LRUMap(256));
+
+    public static ColumnVisibility get(ByteSequence bytes) {
+        ColumnVisibility vis = cache.get(bytes);
+        if (vis == null) {
+            vis = new ColumnVisibility(bytes.toArray());
+            cache.put(bytes, vis);
+        }
+        return vis;
+    }
+}

core/utils/accumulo-utils/src/main/java/datawave/marking/FlattenedVisibilityCache.java

@@ -0,0 +1,41 @@
+package datawave.marking;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.accumulo.core.data.ByteSequence;
+import org.apache.accumulo.core.security.ColumnVisibility;
+
+/**
+ * This is a cache that can be used per process to save flattened visibility calculations.
+ *
+ */
+public class FlattenedVisibilityCache {
+    private static Map<ColumnVisibility,byte[]> flattenedVisCache = Collections.synchronizedMap(new HashMap<>());
+
+    /**
+     * Create a flattened visibility, using the cache if possible
+     *
+     * @param vis
+     *            the visibility to flatten
+     * @return the flattened visibility
+     */
+    public static byte[] flatten(ColumnVisibility vis) {
+        byte[] visBytes = flattenedVisCache.get(vis);
+        if (visBytes == null) {
+            visBytes = vis.flatten();
+            flattenedVisCache.put(vis, visBytes);
+        }
+        return visBytes;
+    }
+
+    public static byte[] flatten(ByteSequence bytes) {
+        return flatten(ColumnVisibilityCache.get(bytes));
+    }
+
+    public static boolean equals(ColumnVisibility left, ColumnVisibility right) {
+        return Arrays.equals(flatten(left), flatten(right));
+    }
+}

core/utils/accumulo-utils/src/main/java/datawave/marking/MarkingFunctions.java

@@ -2,13 +2,16 @@
 
 import static datawave.marking.AccessExpressionMarkings.ACCESS;
 
+import java.nio.charset.StandardCharsets;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.stream.Collectors;
 
 import org.apache.accumulo.access.AccessExpression;
 import org.apache.accumulo.access.ParsedAccessExpression;
+import org.apache.accumulo.core.security.Authorizations;
+import org.apache.accumulo.core.security.ColumnVisibility;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
@@ -22,8 +25,21 @@
 
 public interface MarkingFunctions<T extends Markings<?>> {
 
+    ColumnVisibility combineVisibilities(Collection<ColumnVisibility> visibilities) throws MarkingFunctions.Exception;
+
     T combine(Collection<T> markings) throws MarkingFunctions.Exception;
 
+    ColumnVisibility translateToColumnVisibility(Markings<?> markings) throws MarkingFunctions.Exception;
+
+    Markings<?> translateFromColumnVisibility(ColumnVisibility columnVisibility) throws MarkingFunctions.Exception;
+
+    Markings<?> translateFromColumnVisibilityForAuths(ColumnVisibility columnVisibility, Collection<Authorizations> authorizations)
+                    throws MarkingFunctions.Exception;
+
+    Markings<?> translateFromColumnVisibilityForAuths(ColumnVisibility columnVisibility, Authorizations authorizations) throws MarkingFunctions.Exception;
+
+    byte[] flatten(ColumnVisibility vis);
+
     class Exception extends java.lang.Exception {
 
         public Exception() {
@@ -51,6 +67,11 @@ class Default implements MarkingFunctions<AccessExpressionMarkings> {
 
         private static final AccessExpressionMarkings EMPTY_MARKINGS = AccessExpressionMarkings.builder().accessExpression(ACCESS.newExpression("")).build();
 
+        @Override
+        public ColumnVisibility combineVisibilities(Collection<ColumnVisibility> visibilities) {
+            throw new UnsupportedOperationException();
+        }
+
         @Override
         public AccessExpressionMarkings combine(Collection<AccessExpressionMarkings> markings) {
 
@@ -78,9 +99,35 @@ public AccessExpressionMarkings combine(Collection<AccessExpressionMarkings> mar
             // @formatter:on
 
             // normalize the Parsed Expression and then return a copy without the parse tree
-            // FIXME: Using a beta of the accumulo-access API so temporarily using the normalize function from the example code
             return AccessExpressionMarkings.builder().accessExpression(ACCESS.newExpression(AccessExpressionUtil.normalize(expression).expression)).build();
         }
+
+        @Override
+        public ColumnVisibility translateToColumnVisibility(Markings<?> markings) {
+            AccessExpression accessExpression = AccessExpressionUtil.toAccessExpression(markings);
+            return AccessExpressionUtil.toColumnVisibility(AccessExpressionUtil.normalize(accessExpression));
+        }
+
+        @Override
+        public Markings<?> translateFromColumnVisibility(ColumnVisibility expression) {
+            AccessExpression accessExpression = ACCESS.newExpression(new String(expression.getExpression(), StandardCharsets.UTF_8));
+            return AccessExpressionMarkings.builder().accessExpression(AccessExpressionUtil.normalize(accessExpression)).build();
+        }
+
+        @Override
+        public Markings<?> translateFromColumnVisibilityForAuths(ColumnVisibility columnVisibility, Collection<Authorizations> authorizations) {
+            return translateFromColumnVisibility(columnVisibility);
+        }
+
+        @Override
+        public Markings<?> translateFromColumnVisibilityForAuths(ColumnVisibility columnVisibility, Authorizations authorizations) {
+            return translateFromColumnVisibility(columnVisibility);
+        }
+
+        @Override
+        public byte[] flatten(ColumnVisibility vis) {
+            return FlattenedVisibilityCache.flatten(vis);
+        }
     }
 
     /**