Get all the Ember.Application instances from Ember.Namespace.NAMESPACES
and add our own applicationId and applicationName to them
@return {*}
976869
function getApplications() {
    var namespaces = Ember.A(Ember.Namespace.NAMESPACES);

    var apps = namespaces.filter(function(namespace) {
      return namespace instanceof Ember.Application;
    });

    return apps.map(function(app) {
      // Add applicationId and applicationName to the app
      var applicationId = Ember.guidFor(app);
      var applicationName = app.name || app.modulePrefix || `(unknown app - ${applicationId})`;

      Object.assign(app, {
        applicationId,
        applicationName
      });

      return app;
    });
  }
585878
function () {
    var routes = Array.prototype.slice.call(arguments);
    if (routes.length) {
      Ember.A(routes).forEach(function (child) {
        this._route(child);
      }, this);
    }
    else {
      if (!this.get('isResource')) {
        this.set('isResource', true);
      }
    }
    return this;
  }
779595
public Optional<ApplicationInstance> show(long applicationId, long instanceId)
    {
        return HTTP.GET(String.format("/v2/applications/%d/instances/%d.json", applicationId, instanceId), APPLICATION_INSTANCE);
    }
171795
function cleanupInstanceName(name) {
  let match = name.match(/^.+:(.+)::/);
  if (!match) {
    // Support for Namespace names (instead of module) (for the tests).
    // `<App.ApplicationController:ember301>` => `App.ApplicationController`
    match = name.match(/^<(.+):/);
  }
  if (match) {
    return match[1];
  }
  return name;
}
654970
function () {
      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

      options.base = this;
      return _emberApplicationSystemEngineInstance.default.create(options);
    }
1198597
private function registerAppNamespace()
    {
        // get app namespace
        $namespace = $this->applicationConfig->get('Application.Namespace', false);
        if (!$namespace) {
            throw new BootstrapException('Unable to register application namespace. You must define the application namespace in your App.yaml config file.');
        }

        try{
            // register the namespace
            ClassLoader::getInstance()->registerMap([$namespace => $this->applicationAbsolutePath.'App']);
        }catch (\Exception $e){
            throw new BootstrapException('Unable to register application ('.$namespace.' => '.$this->applicationAbsolutePath.'App'.') namespace with ClassLoader.');
        }

    }
1304400
@Override
    public Set<String> getDependentApplications() {
        Set<String> appsToStop = new HashSet<String>(applications);
        applications.clear();
        return appsToStop;
    }
1192186
private Collection<ApplicationDefinition> findAllApplications(Tenant tenant) {
        List<ApplicationDefinition> result = new ArrayList<>();
        Iterator<DRow> rowIter =
            DBService.instance(tenant).getAllRows(SchemaService.APPS_STORE_NAME).iterator();
        while (rowIter.hasNext()) {
            DRow row = rowIter.next();
            ApplicationDefinition appDef = loadAppRow(tenant, getColumnMap(row.getAllColumns(1024).iterator()));
            if (appDef != null) {
                result.add(appDef);
            }
        }
        return result;
    }
265123
async function mapComponentNameToTwigNamespace() {
  const twigNamespaces = {};
  const manifest = await getBoltManifest();
  const allComponents = [
    ...manifest.components.global,
    ...manifest.components.individual,
  ];
  allComponents.forEach(component => {
    if (component.twigNamespace) {
      twigNamespaces[component.twigNamespace] = component.name;
    }
  });
  return twigNamespaces;
}
1104363
function EmberAddon() {
    var args = [];
    var options = {};
    console.log("Addon init")

    for (var i = 0, l = arguments.length; i < l; i++) {
        args.push(arguments[i]);
    }

    if (args.length === 1) {
        options = args[0];
    } else if (args.length > 1) {
        args.reverse();
        options = defaults.apply(null, args);
    }

    process.env.EMBER_ADDON_ENV = process.env.EMBER_ADDON_ENV || 'development';

    this.appConstructor(defaults(options, {
        name: 'dummy',
        configPath: './tests/dummy/config/environment',
        trees: {
            app: 'tests/dummy/app',
            styles: 'tests/dummy/app/styles',
            templates: 'tests/dummy/app/templates',
            public: 'tests/dummy/public',
            tests: new Funnel('tests', {
                exclude: [ /^dummy/ ]
            })
        },
        jshintrc: {
            tests: './tests',
            app: './tests/dummy'
        },
    }));
}
174185
def namespace_bindings_from_defs(ns_defs)
      (ns_defs||[]).reduce({}) do |h,ns_def|
        h[ns_def.prefix||""] = ns_def.href
        h
      end
    end
1356237
function () {
      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

      options.base = this;
      options.application = this;
      return _emberApplicationSystemApplicationInstance.default.create(options);
    }
313856
def instance_names namespace, classname=nil, properties = {}
    case namespace
    when Openwsman::ObjectPath
      classname = namespace.classname
      properties = namespace.properties
      namespace = namespace.namespace
      uri = epr_uri_for(namespace,classname)
    when Openwsman::EndPointReference
      namespace.each do |k,v|
        properties[k] = v
      end
      classname = namespace.classname
      uri = namespace.resource_uri
      namespace = namespace.namespace
    else
      uri = epr_uri_for(namespace, classname)
    end
    @options.flags = Openwsman::FLAG_ENUMERATION_ENUM_EPR | Openwsman::FLAG_ENUMERATION_OPTIMIZATION
    @options.max_elements = 999
    @options.cim_namespace = namespace if @product == :openwsman
    @options.set_dump_request if Wbem.debug
    @options.selectors = properties unless properties.empty?
    start = Time.now
    STDERR.puts "instance_names enumerate (#{uri})" if Wbem.debug
    result = @client.enumerate( @options, nil, uri )
    names = []
    loop do
      if _handle_fault @client, result
        break
      end
      items = result.Items
      if items
        # expect <n:Item><a:EndpointReference>...
        items.each do |epr|
          names << Openwsman::EndPointReference.new(epr)
        end
      end
      context = result.context
      break unless context
      result = @client.pull( @options, nil, uri, context )
    end
    STDERR.puts "Enumerated #{names.size} items in #{Time.now-start} seconds" if Wbem.debug
    return names
  end
597107
public Application getRegisteredApplications(String appName) {
        return appNameApplicationMap.get(appName.toUpperCase(Locale.ROOT));
    }
591336
function (parsedName) {
      var className = _emberRuntimeSystemString.classify(parsedName.name);
      var factory = _emberMetalProperty_get.get(parsedName.root, className);

      if (factory) {
        return factory;
      }
    }
1051005
private Map<String, String> namespaces(Kam kam) {
        Map<String, String> nsmap = new HashMap<String, String>();

        // find namespaces in resource index
        List<NamespaceDescriptor> ns = nsrsvc.getAllNamespaceDescriptors();
        for (NamespaceDescriptor n : ns) {
            Namespace the_ns = n.getNamespace();
            nsmap.put(the_ns.getPrefix(), the_ns.getResourceLocation());
        }

        // then find namespaces identified by the KAM
        List<org.openbel.framework.api.internal.KAMStoreDaoImpl.Namespace> nsl =
                kAMStore.getNamespaces(kam);
        for (org.openbel.framework.api.internal.KAMStoreDaoImpl.Namespace kam_ns : nsl) {
            nsmap.put(kam_ns.getPrefix(), kam_ns.getResourceLocation());
        }
        return nsmap;
    }
84589
function () {
      var location = _emberMetalProperty_get.get(this, 'location');
      var path = location.pathname;

      var rootURL = _emberMetalProperty_get.get(this, 'rootURL');
      var baseURL = _emberMetalProperty_get.get(this, 'baseURL');

      // remove trailing slashes if they exists
      rootURL = rootURL.replace(/\/$/, '');
      baseURL = baseURL.replace(/\/$/, '');

      // remove baseURL and rootURL from path
      var url = path.replace(baseURL, '').replace(rootURL, '');

      var search = location.search || '';
      url += search;
      url += this.getHash();

      return url;
    }