il.ac.bgu.cs.bp.bpjs.model.eventselection.SimpleEventSelectionStrategy Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of BPjs Show documentation

Provides runtime and analysis for behavioral programs written in JavaScript. It can run stand-alone (from the commmandline) or be embedded in larger JVM-based systems.

There is a newer version: 0.12.3

Show newest version

package il.ac.bgu.cs.bp.bpjs.model.eventselection;

import il.ac.bgu.cs.bp.bpjs.BPjs;
import il.ac.bgu.cs.bp.bpjs.model.SyncStatement;
import il.ac.bgu.cs.bp.bpjs.model.BEvent;
import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot;
import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSet;
import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSets;
import static java.util.Collections.emptySet;
import static java.util.Collections.singleton;
import java.util.List;
import java.util.Set;
import static java.util.stream.Collectors.toSet;
import org.mozilla.javascript.Context;

/**
 * An event selection strategy that:
 * 
 * Randomly selects an internal event that's requested and not blocked

 * 
If no such event is available, selects the first external event that's not blocked
 * If no such event is available, returns an empty result
 * 
 * 
 * Under this strategy, if the selected event is internal, and has {@code equal} events queued externally,
 * these events are not removed.
 * 
 * @author michael
 */
public class SimpleEventSelectionStrategy extends AbstractEventSelectionStrategy {
    
    
    public SimpleEventSelectionStrategy( long seed ) {
        super(seed);
    }
    
    public SimpleEventSelectionStrategy() {}
    
    
    @Override
    public Set selectableEvents(BProgramSyncSnapshot bpss) {
        warnOnHints(bpss);
        Set statements = bpss.getStatements();
        List externalEvents = bpss.getExternalEvents();
        if ( statements.isEmpty() ) {
            // Corner case, not sure this is even possible.
            return externalEvents.isEmpty() ? emptySet() : singleton(externalEvents.get(0));
        }
        
        EventSet blocked = EventSets.anyOf(statements.stream()
                .filter( stmt -> stmt!=null )
                .map(SyncStatement::getBlock )
                .filter(r -> r != EventSets.none )
                .collect( toSet() ) );
        
        Set requested = statements.stream()
                .filter( stmt -> stmt!=null )
                .flatMap( stmt -> stmt.getRequest().stream() )
                .collect( toSet() );
        
        // Let's see what internal events are requested and not blocked (if any).
        try {
            BPjs.enterRhinoContext();
            Set requestedAndNotBlocked = requested.stream()
                    .filter( req -> !blocked.contains(req) )
                    .collect( toSet() );

            return requestedAndNotBlocked.isEmpty() ?
                    externalEvents.stream().filter( e->!blocked.contains(e) ) // No internal events requested, defer to externals.
                                  .findFirst().map( e->singleton(e) ).orElse(emptySet())
                    : requestedAndNotBlocked;
        } finally {
            Context.exit();
        }
    }

}