tmp/ariane-old-core/src/main/java/com/assembla/ariane/jellyfish/proxy/vfc/Users.java

   1 /*******************************************************************************
   2  * Copyright 2012 Fat Cat
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  ******************************************************************************/
  16 package com.assembla.ariane.jellyfish.proxy.vfc;
  17
  18 import java.io.Serializable;
  19 import java.util.Collections;
  20 import java.util.LinkedList;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.TreeMap;
  24 import com.assembla.ariane.jellyfish.util.collections.Pair;
  25
  26 /**
  27  * This class contains an list of users.
  28  * @author Fat Cat
  29  * @version 1
  30  * @since 0.0.7
  31  */
  32 public final class Users implements Serializable
  33 {
  34
  35   /** The class version. */
  36   private static final long serialVersionUID = -6247057140716941819L;
  37
  38   /** The list of users. */
  39   private List<User> users;
  40
  41   /** The singleton object. */
  42   private static final Users inst = new Users( );
  43
  44   /**
  45    * Returns the instance of this singleton.
  46    * @return The users singleton.
  47    */
  48   public static Users instance( )
  49   {
  50     return Users.inst;
  51   }
  52
  53   /**
  54    * Creates a new user list.
  55    */
  56   private Users()
  57   {
  58     this.users = Collections.synchronizedList( new LinkedList< User >( ) );
  59   }
  60
  61   /**
  62    * Returns an read-only list of all users.
  63    * @return An list of all users.
  64    */
  65   public synchronized List< User > getUsers( )
  66   {
  67     return Collections.unmodifiableList( this.users );
  68   }
  69
  70   /**
  71    * Checks if the given user name is known.
  72    * @param username The name of the user to look for.
  73    * @return True, if the user exists.
  74    */
  75   public synchronized boolean hasUserName( final String username )
  76   {
  77     for( User user : this.users )
  78     {
  79       if( user.getUserName( ).equals( username ) )
  80       {
  81         return true;
  82       }
  83     }
  84     return false;
  85   }
  86
  87   /**
  88    * Returns the user with the given name, or null if the user does not exist.
  89    * @param username The name of the user to return.
  90    * @return The corresponding user.
  91    */
  92   public synchronized User getUserFor( final String username )
  93   {
  94     for( User user : this.users )
  95     {
  96       if( user.getUserName( ).equals( username ) )
  97       {
  98         return user;
  99       }
 100     }
 101     return null;
 102   }
 103
 104   /**
 105    * Adds a user to the list of all users.
 106    * @param user The user to add to the list.
 107    */
 108   public synchronized void addUser( final User user )
 109   {
 110     if( ( user != null ) &&
 111         ( user.getPivots( ).isEmpty( ) ) &&
 112         !this.users.contains( user ) )
 113     {
 114       this.users.add( user );
 115     }
 116   }
 117
 118   /**
 119    * Removes the given user from the user list.
 120    * @param user The user to remove.
 121    */
 122   public synchronized void removeUser( final User user )
 123   {
 124     if( ( user != null ) && this.users.contains( user ) )
 125     {
 126       this.users.remove( user );
 127     }
 128   }
 129
 130   /**
 131    * Checks if the needed page needs remapping.
 132    * @param page The page to check.
 133    * @return True, if the page needs remapping.
 134    */
 135   public boolean isRemapNeeded( final VFCPage page )
 136   {
 137     for( User user : this.users )
 138     {
 139       if( user.isRemapNeeded( page ) )
 140       {
 141         return true;
 142       }
 143     }
 144     return false;
 145   }
 146
 147   /**
 148    * Remapps the given page.
 149    * @param page The page to remap.
 150    */
 151   public void remapAsNeeded( final VFCPage page )
 152   {
 153     for( User user : this.users )
 154     {
 155       user.remapAsNeeded( page );
 156     }
 157   }
 158
 159   /**
 160    * Returns an list of pivots for the given page, grouped by user.
 161    * @param page The page to return the pivot list.
 162    * @return An pivot list, grouped by user.
 163    */
 164   public Map<User, List<Pivot>> getPivotsFor( final VFCPage page )
 165   {
 166     final Map< User, List<Pivot> > map = new TreeMap< User, List<Pivot> >( User.USER_NAME_COMPARATOR );
 167
 168     for( User user : this.users )
 169     {
 170       if( user.isPageKnown( page ) )
 171       {
 172         map.put( user, user.getPivotsFor( page ) );
 173       }
 174     }
 175
 176     return Collections.unmodifiableMap( map );
 177   }
 178
 179   /**
 180    * Returns if the page url is known (and if it is known for the given user or not).
 181    * @param url The page url to look for.
 182    * @param user The user that should known about the page.
 183    * @return An object with the collected information.
 184    */
 185   public PageState isPageKnown( final String url, final User user )
 186   {
 187     boolean pageKnown = false;
 188     for( User currentUser : this.users )
 189     {
 190       if( currentUser.isPageKnown( url ) )
 191       {
 192         if ( User.USER_NAME_COMPARATOR.compare( user, currentUser ) == 0 )
 193         {
 194           return PageState.PAGE_KNOWN_FOR_USER;
 195         }
 196         else
 197         {
 198           pageKnown = true;
 199         }
 200       }
 201     }
 202     if( pageKnown )
 203     {
 204       return PageState.PAGE_KNOWN;
 205     }
 206
 207     return PageState.PAGE_UNKNOWN;
 208   }
 209
 210   /**
 211    * Returns the page with the given url. (Checking also if the given user known the page )
 212    * @param url The url of the page to return.
 213    * @param user The user that should known the page.
 214    * @return An tuple with information about the user containing the page,
 215    * and the page with the given url.
 216    */
 217   public Pair<PageState, VFCPage> peekPageInformation( final String url, final User user )
 218   {
 219     VFCPage page = null;
 220     VFCPage compPage = null;
 221
 222     for( User currentUser : this.users )
 223     {
 224       compPage = currentUser.peekPageInformation( url );
 225       if( compPage != null )
 226       {
 227         if ( User.USER_NAME_COMPARATOR.compare( user, currentUser ) == 0 )
 228         {
 229           return new Pair<PageState, VFCPage>( PageState.PAGE_KNOWN_FOR_USER, compPage );
 230         }
 231         else
 232         {
 233           page = compPage;
 234         }
 235       }
 236     }
 237     if( page != null )
 238     {
 239       return new Pair<PageState, VFCPage>( PageState.PAGE_KNOWN, page );
 240     }
 241     return new Pair<PageState, VFCPage>( PageState.PAGE_UNKNOWN, null );
 242   }
 243 }