package org.astrogrid.samp; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * Represents the set of subscribed messages for a SAMP client. * This has the form of a Map in which each key is an MType (perhaps * wildcarded) and the corresponding values are maps with keys which are * so far undefined (thus typically empty). * * @author Mark Taylor * @since 14 Jul 2008 */ public class Subscriptions extends SampMap { private static final String ATOM_REGEX = "[0-9a-zA-Z\\-_]+"; private static String MTYPE_REGEX = "(" + ATOM_REGEX + "\\.)*" + ATOM_REGEX; private static String MSUB_REGEX = "(" + MTYPE_REGEX + "|" + MTYPE_REGEX + "\\.\\*" + "|" + "\\*" + ")"; private static final Pattern MSUB_PATTERN = Pattern.compile( MSUB_REGEX ); /** * Constructs an empty subscriptions object. */ public Subscriptions() { super( new String[ 0 ] ); } /** * Constructs a subscriptions object based on an existing map. * * @param map map containing initial data for this object */ public Subscriptions( Map map ) { this(); putAll( map ); } /** * Adds a subscription to a given MType. mtype may include * a wildcard according to the SAMP rules. * * @param mtype subscribed MType, possibly wildcarded */ public void addMType( String mtype ) { put( mtype, new HashMap() ); } /** * Determines whether a given (non-wildcarded) MType is subscribed to * by this object. * * @param mtype MType to test */ public boolean isSubscribed( String mtype ) { if ( containsKey( mtype ) ) { return true; } for ( Iterator it = keySet().iterator(); it.hasNext(); ) { if ( matchLevel( (String) it.next(), mtype ) >= 0 ) { return true; } } return false; } /** * Returns the map which forms the value for a given MType key. * If a wildcarded subscription is recorded which matches * mtype, the corresponding value is returned. * If mtype is not subscribed to, null * is returned. * * @param mtype MType to query * @return map value corresponding to mtype, or null */ public Map getSubscription( String mtype ) { if ( containsKey( mtype ) ) { Object value = get( mtype ); return value instanceof Map ? (Map) value : (Map) new HashMap(); } else { int bestLevel = -1; Map bestValue = null; for ( Iterator it = entrySet().iterator(); it.hasNext(); ) { Map.Entry entry = (Map.Entry) it.next(); int level = matchLevel( (String) entry.getKey(), mtype ); if ( level > bestLevel ) { bestLevel = level; Object value = entry.getValue(); bestValue = value instanceof Map ? (Map) value : (Map) new HashMap(); } } return bestValue; } } public void check() { super.check(); for ( Iterator it = entrySet().iterator(); it.hasNext(); ) { Map.Entry entry = (Map.Entry) it.next(); String key = (String) entry.getKey(); Object value = entry.getValue(); if ( ! MSUB_PATTERN.matcher( key ).matches() ) { throw new DataException( "Illegal subscription key " + "\"" + key + "\"" ); } if ( ! ( value instanceof Map ) ) { throw new DataException( "Subscription values " + "are not all maps" ); } } } /** * Returns a given map in the form of a Subscriptions object. * * @param map map * @return subscriptions */ public static Subscriptions asSubscriptions( Map map ) { return ( map instanceof Subscriptions || map == null ) ? (Subscriptions) map : new Subscriptions( map ); } /** * Performs wildcard matching of MTypes. The result is the number of * dot-separated "atoms" which match between the two. * * @param pattern MType pattern; may contain a wildcard * @param mtype unwildcarded MType for comparison with * pattern * @return the number of atoms of pattern which match * mtype; if pattern="*" the result is * 0, and if there is no match the result is -1 */ public static int matchLevel( String pattern, String mtype ) { if ( mtype.equals( pattern ) ) { return countAtoms( pattern ); } else if ( "*".equals( pattern ) ) { return 0; } else if ( pattern.endsWith( ".*" ) ) { String prefix = pattern.substring( 0, pattern.length() - 2 ); return mtype.startsWith( prefix ) ? countAtoms( prefix ) : -1; } else { return -1; } } /** * Counts the number of dot-separated "atoms" in a string. * * @param text string to test */ private static int countAtoms( String text ) { int leng = text.length(); int natom = 1; for ( int i = 0; i < leng; i++ ) { if ( text.charAt( i ) == '.' ) { natom++; } } return natom; } }