Author: sannegrinovero
Date: 2008-08-01 13:10:49 -0400 (Fri, 01 Aug 2008)
New Revision: 15014

Modified:
 search/trunk/src/java/org/hibernate/search/backend/configuration/MaskedProperty.java
 search/trunk/src/test/org/hibernate/search/test/configuration/MaskedPropertiesTest.java
Log:
additional fixes for HSEARCH-241: recursive listing, inclusion of fallback properties in lists, synchronization, isEmpty().

Modified: search/trunk/src/java/org/hibernate/search/backend/configuration/MaskedProperty.java
===================================================================
--- search/trunk/src/java/org/hibernate/search/backend/configuration/MaskedProperty.java  2008-08-01 12:23:25 UTC (rev 15013)
+++ search/trunk/src/java/org/hibernate/search/backend/configuration/MaskedProperty.java  2008-08-01 17:10:49 UTC (rev 15014)
@@(protected) @@
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.Collection;
+import java.util.Collections;
import java.util.Enumeration;
import java.util.InvalidPropertiesFormatException;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
+import java.util.TreeSet;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@(protected) @@
* A wrapper to Properties, to restrict the availability of
* values to only those which have a key beginning with some
* masking String.
- * Supported methods to enumerate the lsit of properties are:
+ * Supported methods to enumerate the list of properties are:
*  - propertyNames()
*  - keySet()
*  - keys()
@@(protected) @@
 private final Properties masked;
 private final Properties fallBack;
 private final String radix;
-  private transient List<String> propertyNames;
+  private transient Set<Object> propertyNames;
 
 /**
  * Provides a view to the provided Properties hiding
@@(protected) @@
 @Override
 public Enumeration<?> propertyNames() {
   initPropertyNames();
-    return new PropertyNameEnumeration();
+    return Collections.enumeration( propertyNames );
 }

-  private void initPropertyNames() {
+  private synchronized void initPropertyNames() {
   if ( propertyNames != null) return;
-    propertyNames = new ArrayList<String>();
-    List<String> maskedProperties = new ArrayList<String>();
+    Set<Object> maskedProperties = new TreeSet<Object>();
   //we use keys to be safe and avoid CCE for non String key entries
-    Enumeration maskedNames = masked.keys();
+    Enumeration<?> maskedNames = masked.propertyNames();
   while ( maskedNames.hasMoreElements() ) {
     Object key = maskedNames.nextElement();
     if ( String.class.isInstance( key ) ) {
       String maskedProperty = (String) key;
       if ( maskedProperty.startsWith( radix ) ) {
-          maskedProperties.add(maskedProperty);
-          propertyNames.add(maskedProperty.substring( radix.length(), maskedProperty.length() ) );
+          maskedProperties.add(maskedProperty.substring( radix.length(), maskedProperty.length() ) );
       }
     }
   }
   if (fallBack != null) {
-      Enumeration fallbackKeys = fallBack.keys();
-      while ( fallbackKeys.hasMoreElements() ) {
-        Object key = fallbackKeys.nextElement();
+      Enumeration<?> fallBackNames = fallBack.propertyNames();
+      while ( fallBackNames.hasMoreElements() ) {
+        Object key = fallBackNames.nextElement();
       if ( String.class.isInstance( key ) ) {
-          String fallbackProperty = (String) key;
-          if ( ! maskedProperties.contains( fallbackProperty )) {
-            propertyNames.add(fallbackProperty);
-          }
+          maskedProperties.add( (String) key );
       }
     }
   }
+    propertyNames = Collections.unmodifiableSet( maskedProperties );
 }
 
 /**
@@(protected) @@

 @Override
 public boolean isEmpty() {
-    if ( fallBack==null ) {
-      return masked.isEmpty();
-    }
-    else {
-      return masked.isEmpty() && fallBack.isEmpty();
-    }
+    initPropertyNames();
+    return propertyNames.isEmpty();
 }

 /**
@@(protected) @@
 @Override
 public Enumeration<Object> keys() {
   initPropertyNames();
-    return new PropertyNameEnumeration();
+    return Collections.enumeration( propertyNames );
 }

 @Override
 public Set<Object> keySet() {
   initPropertyNames();
-    return new HashSet<Object>(propertyNames);
+    return propertyNames;
 }

 /**
@@(protected) @@
   aOutputStream.defaultWriteObject();
 }

-  private class PropertyNameEnumeration implements Enumeration<Object> {
-    private int index = -1;
-
-    public boolean hasMoreElements() {
-      return index + 1 < propertyNames.size();
-    }
-
-    public Object nextElement() {
-      index++;
-      return propertyNames.get( index );
-    }
-  }
}

Modified: search/trunk/src/test/org/hibernate/search/test/configuration/MaskedPropertiesTest.java
===================================================================
--- search/trunk/src/test/org/hibernate/search/test/configuration/MaskedPropertiesTest.java  2008-08-01 12:23:25 UTC (rev 15013)
+++ search/trunk/src/test/org/hibernate/search/test/configuration/MaskedPropertiesTest.java  2008-08-01 17:10:49 UTC (rev 15014)
@@(protected) @@
   assertEquals( "value", theCopy.getProperty( "key" ) );
 }
 
+  public void testListingKeys() {
+    Properties defaultProp = new Properties();
+    defaultProp.put( "some.inherited.prop", "to test standard Properties fallback behaviour" );
+    Properties rootProp = new Properties( defaultProp );
+    rootProp.put( "some.long.dotted.prop1", "hello!" );
+    rootProp.put( "hidden.long.dotted.prop2", "hello again" );
+    Properties fallbackProp = new Properties();
+    fallbackProp.put( "default.long.dotted.prop3", "hello!" );
+    Properties masked = new MaskedProperty( rootProp, "some", fallbackProp );
+    
+    assertTrue( masked.keySet().contains( "long.dotted.prop1" ) );
+    assertTrue( masked.keySet().contains( "default.long.dotted.prop3" ) );
+    assertTrue( masked.keySet().contains( "inherited.prop" ) );
+    assertFalse( masked.keySet().contains( "hidden.long.dotted.prop2" ) );
+    assertFalse( masked.keySet().contains( "long.dotted.prop2" ) );
+    
+    Properties maskedAgain = new MaskedProperty( masked, "long.dotted", masked ); //falling back to same instance for **
+    assertTrue( maskedAgain.keySet().contains( "prop1" ) );
+    assertTrue( maskedAgain.keySet().contains( "long.dotted.prop1" ) ); //**: prop 1 should be visible in both ways
+    assertTrue( maskedAgain.keySet().contains( "default.long.dotted.prop3" ) );
+    
+    Properties maskingAll = new MaskedProperty( masked, "secured" );
+    assertTrue( maskingAll.keySet().isEmpty() );
+    assertTrue( maskingAll.isEmpty() );
+  }
+  
}

_______________________________________________
hibernate-commits mailing list
hibernate-commits@(protected)
https://lists.jboss.org/mailman/listinfo/hibernate-commits