Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
 package edu.mit.simile.butterfly;
 
 import java.util.Map;
 import java.util.Set;
 
This class represents the "scope" of that is given to a javascript controller and contains all the various objects that the controller might need to interact with the system.
public class ButterflyScope extends ScriptableObject {
    private static final long serialVersionUID = -7468104001568307817L;
    protected static final Logger _logger = LoggerFactory.getLogger("butterfly.scope");
    
    public ButterflyScope(ButterflyModule moduleContext contextthrows Exception {
    	.trace("> new ButterflyScope for module: {}"module.getName());
    	
        // first, get a juicy top level scope that contains all the ECMA
        // objects and some Java related utility methods that Rhino provides
        Scriptable scope = new ImporterTopLevel(context);
        
        // make the "ButteflyModule" object available to this scope
        defineClass(scopeScriptableButterfly.class);
        // and set this scope as our prototype
        setPrototype(scope);
        // We want this to be a new top-level scope, so set its
        // parent scope to null. This means that any variables created
        // by assignments will be properties of this.
        setParentScope(null);
        // We need to create an instance of the ButterflyModule object and 
        // inject it into this scope. We keep a reference to this instance
        // because it's what we'll need to know if the controller has responded
        // to the request or not
        final Object[] args = {};
        ScriptableButterfly _scriptableButterfly = (ScriptableButterflycontext.newObject(this, ScriptableButterfly.getName(), args);
        _scriptableButterfly.init(module);
        _scriptableButterfly.setParentScope(this);
        super.put("butterfly"this_scriptableButterfly);
        super.put("module"thismodule);
        
        prepareScope(contextscopemodule);
    	.trace("< new ButterflyScope for module: {}"module.getName());
    }
    private void prepareScope(Context contextScriptable scopeButterflyModule modulethrows Exception {
    	.trace("> prepareScope({})"module.getName());
    	
        Map<String,ButterflyModuledependencies = module.getDependencies();
        
        for (ButterflyModule m : dependencies.values()) {
        	prepareScope(contextscopem);
        }
        Set<ButterflyScriptableObjectscriptables = module.getScriptables();
        final Object[] args = {};
        
    	// make the scriptable classes available to this scope 
        // (both as classes and instances)
        Iterator<ButterflyScriptableObjecti = scriptables.iterator();
        while (i.hasNext()) {
        	ButterflyScriptableObject c = i.next();
            defineClass(scopec.getClass());
        	.debug("defined class: {}"c.getClassName());
            ButterflyScriptableObject scriptable = (ButterflyScriptableObjectcontext.newObject(thisc.getClassName(), args);
            scriptable.init(module);
            scriptable.setParentScope(this);
            Set<Stringimplementations = module.getImplementations();
            for (String name : implementations) {
	            super.put(name, thisscriptable);
	        	.debug("defined instance: {}"name);
            }
        }
        .trace("< prepareScope({})"module.getName());
    }
    public String getClassName() {
        return "ButterflyScope";
    }
New to GrepCode? Check out our FAQ X