handles may be a {@link #TOKEN} separated
+ * String of handles or just a single handle.
+ *
+ *
+ * @param handles a single handle or a {@link #TOKEN} separated
+ * list of handles.
+ * @param type the mask type for the handles
+ */
+ private void addMask( String handles, MaskType type )
+ {
+ StringTokenizer st = new StringTokenizer( handles, TOKEN );
+ while ( st.hasMoreTokens() )
+ {
+ String handle = st.nextToken().trim();
+ log.info( "Masking handle [" + handle + "] from [" + type + "]" );
+ mgr.addMask( handle, type );
+ }
+ }
+
+ /**
+ * Checks with the MaskManager for a mask type for
+ * handle.
+ *
+ * If the MaskManager knows that handle is masked,
+ * it will return a BitSet of mask flags. This method
+ * checks to see if the flag for type is set.
+ *
+ * @param handle the DSpace object handle
+ * @param type the type of masking
+ * @return true if handle is masked for type
+ */
+ private boolean isMaskedInternal( String handle, MaskType type )
+ {
+ BitSet mask = mgr.getMask( handle );
+
+ if ( mgr.getBitIndex( type ) != -1 && mask != null )
+ {
+ if ( mask.get( mgr.getBitIndex( type ) ) )
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Check to see if a DSpace Item is masked.
+ *
+ * An Item is masked if one of the following
+ * conditions is true:
+ * + *
MaskManager asserts the Item is maskedMap
+ * of DSpace handles to masks. The map is not persisted in any way,
+ * so it must be seeded by calling {@link #addMask(String, MaskType)}
+ * each time this object is instantiated. This implementation is
+ * designed to be threadsafe. It can be shared by multiple {@link MaskService}
+ * instances.
+ *
+ * @see MaskService
+ */
+class InMemoryMaskManager implements MaskManager
+{
+ /**
+ * Logger
+ */
+ private Log log = LogFactory.getLog( InMemoryMaskManager.class );
+
+ /**
+ * Maps DSpace object handles to thier mask information.
+ * This Map is meant to serve as a cache.
+ *
+ * This map is shared amongst all instances of this class.
+ * The map is mutable. Access to the map is threadsafe, note
+ * however that update operations like put and
+ * set may interleave retrieval operations like
+ * get per the {@link ConcurrentHashMap} contract.
+ * Interleaving retrievals and updates is a reasonable sacrifice
+ * for reducing lock contention and synchronization overhead.
+ */
+ private static ConcurrentMaptype.
+ *
+ * @param type the {@link MaskType}
+ * @return the bit index of the type, or -1 if no mapping exists.
+ */
+ int getBitIndex( MaskType type )
+ {
+ if (! typeToBit.containsKey( type ) )
+ {
+ return -1;
+ }
+
+ return typeToBit.get( type );
+ }
+
+ private synchronized void putNewMask( String handle, BitSet maskBits )
+ {
+ log.debug( "Adding new mask for " + handle );
+ DspaceObjectMask dsMask = new DspaceObjectMask( handle, maskBits );
+ masks.put( handle, dsMask );
+ }
+
+ /**
+ * Encapsulates all the masks of a particular handle. References to member
+ * objects should never be handed out.
+ */
+ private class DspaceObjectMask
+ {
+ final String handle;
+ final BitSet mask;
+
+ private DspaceObjectMask( String handle )
+ {
+ if ( handle == null || handle.trim().equals( "" ) )
+ {
+ throw new IllegalArgumentException( "Handle must not be empty or null." );
+ }
+ this.handle = handle;
+ this.mask = new BitSet( MaskType.values().length );
+ }
+
+ private DspaceObjectMask( String handle, BitSet mask )
+ {
+ if ( handle == null || handle.trim().equals( "" ) )
+ {
+ throw new IllegalArgumentException( "Handle must not be empty or null." );
+ }
+
+ if ( mask == null )
+ {
+ throw new IllegalArgumentException( "Mask must not be null." );
+ }
+ this.handle = handle;
+ this.mask = mask;
+ }
+
+ public int hashCode()
+ {
+ final int PRIME = 31;
+ int result = 1;
+ result = PRIME * result + ( ( handle == null ) ? 0 : handle.hashCode() );
+ result = PRIME * result + ( ( mask == null ) ? 0 : mask.hashCode() );
+ return result;
+ }
+
+ public boolean equals( Object obj )
+ {
+ if ( this == obj )
+ return true;
+ if ( obj == null )
+ return false;
+ if ( getClass() != obj.getClass() )
+ return false;
+ final DspaceObjectMask other = (DspaceObjectMask) obj;
+ if ( handle == null )
+ {
+ if ( other.handle != null )
+ return false;
+ }
+ else if ( !handle.equals( other.handle ) )
+ return false;
+ if ( mask == null )
+ {
+ if ( other.mask != null )
+ return false;
+ }
+ else if ( !mask.equals( other.mask ) )
+ return false;
+ return true;
+ }
+
+ public String toString()
+ {
+ return "Mask handle: [" + handle + "] mask: [" + mask.toString() + "]";
+ }
+
+ }
+
+}
Property changes on: src/org/dspace/mask/InMemoryMaskManager.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Index: src/org/dspace/mask/MaskManager.java
===================================================================
--- src/org/dspace/mask/MaskManager.java (revision 0)
+++ src/org/dspace/mask/MaskManager.java (revision 5020)
@@ -0,0 +1,38 @@
+package org.dspace.mask;
+
+/**
+ * Responsible for managing the masks which
+ * are placed on DSpace objects.
+ *
+ * This interface should not be exposed.
+ */
+interface MaskManager
+{
+ /**
+ * Mask the handle entirely: all
+ * masks are enabled.
+ */
+ void mask( String handle );
+
+ /**
+ * Unmask the handle entirely: all
+ * masks are removed.
+ */
+ void unmask( String handle );
+
+ /**
+ * Add a mask to the handle.
+ *
+ * @param handle the handle
+ * @param type the mask type
+ */
+ void addMask( String handle, MaskType type );
+
+ /**
+ * Remove a mask from a handle
+ *
+ * @param handle the handle
+ * @param type the mask type
+ */
+ void removeMask( String handle, MaskType type );
+}
Property changes on: src/org/dspace/mask/MaskManager.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Index: src/org/dspace/mask/MaskService.java
===================================================================
--- src/org/dspace/mask/MaskService.java (revision 0)
+++ src/org/dspace/mask/MaskService.java (revision 5020)
@@ -0,0 +1,19 @@
+package org.dspace.mask;
+
+/**
+ * The MaskService is responsible for determining if
+ * the object represented by handle should be masked
+ * for the operation represented by the {@link MaskType} type.
+ */
+public interface MaskService
+{
+ /**
+ * Determine if handle should be masked for
+ * type.
+ *
+ * @param handle the handle identifying the object
+ * @param type the type of mask
+ * @return true if the object should be masked
+ */
+ public boolean isMasked( String handle, MaskType type );
+}
Property changes on: src/org/dspace/mask/MaskService.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Index: src/org/dspace/mask/MaskType.java
===================================================================
--- src/org/dspace/mask/MaskType.java (revision 0)
+++ src/org/dspace/mask/MaskType.java (revision 5020)
@@ -0,0 +1,8 @@
+package org.dspace.mask;
+
+public enum MaskType
+{
+ BROWSE,
+ HARVEST,
+ INDEX
+}
Property changes on: src/org/dspace/mask/MaskType.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native