Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package brooklyn.policy.followthesun;
  
  import java.util.HashSet;
  import java.util.Set;
  
  import org.slf4j.Logger;
  
 
 public class FollowTheSunPoolImpl extends AbstractEntity implements FollowTheSunPool {
 
     // FIXME Remove duplication from BalanceableWorkerPool?
 
     // FIXME Asymmetry between loadbalancing and followTheSun: ITEM_ADDED and ITEM_REMOVED in loadbalancing
     // are of type ContainerItemPair, but in followTheSun it is just the `Entity item`.
     
     private static final Logger LOG = LoggerFactory.getLogger(FollowTheSunPool.class);
 
     private Group containerGroup;
     private Group itemGroup;
 
     private final Set<Entitycontainers = Collections.synchronizedSet(new HashSet<Entity>());
     private final Set<Entityitems = Collections.synchronizedSet(new HashSet<Entity>());
 
     private final SensorEventListener<ObjecteventHandler = new SensorEventListener<Object>() {
         @Override
         public void onEvent(SensorEvent<Objectevent) {
             if (.isTraceEnabled()) .trace("{} received event {}"FollowTheSunPoolImpl.thisevent);
             Entity source = event.getSource();
             Object value = event.getValue();
             Sensor sensor = event.getSensor();
 
             if (sensor.equals(.)) {
                 if (source.equals()) {
                     onContainerAdded((Entityvalue);
                 } else if (source.equals()) {
                     onItemAdded((Entity)value);
                 } else {
                     throw new IllegalStateException("unexpected event source="+source);
                 }
             } else if (sensor.equals(.)) {
                 if (source.equals()) {
                     onContainerRemoved((Entityvalue);
                 } else if (source.equals()) {
                     onItemRemoved((Entityvalue);
                 } else {
                     throw new IllegalStateException("unexpected event source="+source);
                 }
             } else if (sensor.equals(.)) {
                 // TODO What if start has failed? Is there a sensor to indicate that?
                 if ((Boolean)value) {
                     onContainerUp(source);
                 } else {
                     onContainerDown(source);
                 }
             } else if (sensor.equals(.)) {
                 onItemMoved(source, (Entityvalue);
             } else {
                 throw new IllegalStateException("Unhandled event type "+sensor+": "+event);
             }
         }
     };
 
     public FollowTheSunPoolImpl() {
     }
 
     @Override
     public void setContents(Group containerGroupGroup itemGroup) {
         this. = containerGroup;
         this. = itemGroup;
         subscribe(containerGroup.);
         subscribe(containerGroup.);
         subscribe(itemGroup.);
         subscribe(itemGroup.);
 
         // Process extant containers and items
         for (Entity existingContainer : containerGroup.getMembers()) {
             onContainerAdded(existingContainer);
         }
         for (Entity existingItem : itemGroup.getMembers()) {
             onItemAdded((Entity)existingItem);
         }
     }
 
     @Override
     public Group getContainerGroup() {
         return ;
     }
    @Override
    public Group getItemGroup() {
        return ;
    }
    @Override
    public Integer getCurrentSize() {
        return .getCurrentSize();
    }
    @Override
    public Integer resize(Integer desiredSize) {
        if ( instanceof Resizablereturn ((Resizable).resize(desiredSize);
        throw new UnsupportedOperationException("Container group is not resizable");
    }
    private void onContainerAdded(Entity newContainer) {
        subscribe(newContainer.);
        if (!(newContainer instanceof Startable) || ..equals(newContainer.getAttribute(.))) {
            onContainerUp(newContainer);
        }
    }
    private void onContainerUp(Entity newContainer) {
        if (.add(newContainer)) {
            emit(newContainer);
        }
    }
    private void onContainerDown(Entity oldContainer) {
        if (.remove(oldContainer)) {
            emit(oldContainer);
        }
    }
    private void onContainerRemoved(Entity oldContainer) {
        unsubscribe(oldContainer);
        onContainerDown(oldContainer);
    }
    private void onItemAdded(Entity item) {
        if (.add(item)) {
            subscribe(item.);
            emit(item);
        }
    }
    private void onItemRemoved(Entity item) {
        if (.remove(item)) {
            unsubscribe(item);
            emit(item);
        }
    }
    private void onItemMoved(Entity itemEntity container) {
        emit(new ContainerItemPair(containeritem));
    }
New to GrepCode? Check out our FAQ X