determineInjectionKeys(config),
971656
function (vueCreateElement, context) {
            const
                props = context.props, // mixProps(context.props, context.listeners, context.injections, defaultValues, config),
                content = componentFunction(props);

            return renderContent(vueCreateElement, content, this);
        }
1224061
def key?(key)
      configuration.key?(key.to_sym) || config_contexts.key?(key.to_sym)
    end
823371
void resolveInjectionBindings()
                    throws InjectionException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "resolveInjectionBindings: " + this);

        Collection<InjectionBinding<A>> allInjectionBindings = ivAllAnnotationsCollection.values();
        for (InjectionBinding<A> injectionBinding : allInjectionBindings)
        {
            if (injectionBinding.ivResolveAttempted) // F87539
            {
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "skipping already resolved " + injectionBinding.toSimpleString());
                continue;
            }

            if (isTraceOn && tc.isDebugEnabled())
                Tr.debug(tc, "resolving " + injectionBinding.toSimpleString());

            injectionBinding.resolveJndiName(); // F743-29417
            resolve(injectionBinding);
            injectionBinding.ivResolveAttempted = true; // F87539

            InjectionScope scope = injectionBinding.getInjectionScope();
            if (scope != InjectionScope.COMP &&
                ivContext.ivSaveNonCompInjectionBindings) // F743-33811.2
            {
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "saving " + scope + " injection binding " + injectionBinding.toSimpleString());

                Map<Class<?>, Map<String, InjectionBinding<?>>> savedInjectionBindings;
                if (scope == InjectionScope.MODULE)
                {
                    savedInjectionBindings = ivContext.ivSavedModuleInjectionBindings;
                }
                else if (scope == InjectionScope.APP)
                {
                    savedInjectionBindings = ivContext.ivSavedAppInjectionBindings;
                }
                else
                {
                    savedInjectionBindings = ivContext.ivSavedGlobalInjectionBindings;
                }

                Map<String, InjectionBinding<A>> injectionBindingsMap = getSavedInjectionBindings(savedInjectionBindings, true);
                String jndiName = injectionBinding.getJndiName();
                InjectionBinding<A> savedBinding = injectionBindingsMap.get(jndiName);
                if (savedBinding == null)
                {
                    injectionBindingsMap.put(jndiName, injectionBinding);
                }
                else
                {
                    savedBinding.mergeSaved(injectionBinding);
                }
            }
        }

        // F743-21481
        // Add all of the InjectionBindings that this processor instance knows
        // about (these InjectionBinding instances are now resolved) so they can
        // later be used to determine the injection targets for a class.
        ivContext.ivProcessedInjectionBindings.addAll(allInjectionBindings); // F743-33811.1

        if (ivSimpleInjectionBindings != null) // F50309.5 PM88594
        {
            Collection<InjectionBinding<A>> injectionBindings = ivSimpleInjectionBindings.values();
            for (InjectionBinding<A> injectionBinding : injectionBindings)
            {
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "resolving " + injectionBinding.toSimpleString());

                resolve(injectionBinding);
            }

            ivContext.ivProcessedInjectionBindings.addAll(injectionBindings);
        }

        if (!ivMissingBindings.isEmpty()) {
            Iterator<String> missingBindingIter = ivMissingBindings.iterator();
            String resRefName;
            String displayName = ivNameSpaceConfig.getDisplayName();
            while (missingBindingIter.hasNext()) {
                resRefName = missingBindingIter.next();
                Tr.error(tc, "UNABLE_TO_RESOLVE_THE_RESOURCE_REFERENCE_CWNEN0044E", resRefName, displayName);
            }
            throw new InjectionException("CWNEN0044E: A resource reference binding could not be found for the following resource references " + ivMissingBindings.toString()
                                         + ", defined for the " + displayName + " component.");
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "resolveInjectionBindings");
    }
1126478
private Set<GinjectorBindings> getSourceGinjectors(Key<?> key) {
    Set<GinjectorBindings> sourceInjectors = new LinkedHashSet<GinjectorBindings>();
    for (Dependency dep : output.getGraph().getDependenciesOf(key)) {
      sourceInjectors.add(positions.get(dep.getTarget()));
    }
    return sourceInjectors;
  }
729313
private Configuration getConfigurationInternal(final String[] keys) {

		Configuration conf = new Configuration();

		synchronized (this.confData) {

			final Iterator<String> it = this.confData.keySet().iterator();

			while (it.hasNext()) {

				final String key = it.next();
				boolean found = false;
				if (keys != null) {
					for (int i = 0; i < keys.length; i++) {
						if (key.equals(keys[i])) {
							found = true;
							break;
						}
					}

					if (found) {
						conf.setString(key, this.confData.get(key));
					}
				} else {
					conf.setString(key, this.confData.get(key));
				}
			}
		}

		return conf;
	}
494293
def injectables_spec_for_key(self, key):
    
    specs = self.injectables_specs_for_key(key)
    specs_len = len(specs)
    if specs_len == 0:
      return None
    if specs_len != 1:
      raise self.TooManySpecsForKey('injectables spec mapping for key included {} elements, '
                                    'expected 1'.format(specs_len))
    return specs[0]
1294341
def _find_keys(self):
        
        formatter = string.Formatter()
        return [
            val[1] for val in formatter.parse(self._original_filter) if val[1]
        ]
349680
def _validate(self):
        
        for key in self:
            if key not in DEFAULTS:
                raise exceptions.ConfigurationException(
                    'Unknown configuration key "{}"! Valid configuration keys are'
                    " {}".format(key, list(DEFAULTS.keys()))
                )

        validate_queues(self["queues"])
        validate_bindings(self["bindings"])
        validate_client_properties(self["client_properties"])
994257
def keys(cls, section=None):
        """"""
        section = section or cls._default_sect
        if section not in cls._conf:
            cls._load(section=section)
        return cls._conf[section].keys()
855966
def values
      VALID_CONFIGURATION_KEYS.inject({}){|o,k| o.merge!(k => send(k)) }
    end
611464
private void registerGinjectorBinding() {
    Key<? extends Ginjector> ginjectorKey = Key.get(ginjectorInterface);
    rootGinjectorBindings.addBinding(ginjectorKey, bindingFactory.getGinjectorBinding());
  }
1061026
function checkKeyCodes (
  eventKeyCode,
  key,
  builtInAlias
) {
  var keyCodes = config.keyCodes[key] || builtInAlias;
  if (Array.isArray(keyCodes)) {
    return keyCodes.indexOf(eventKeyCode) === -1
  } else {
    return keyCodes !== eventKeyCode
  }
}
1305950
private GinjectorBindings findSource(GinjectorBindings ginjector, Key<?> key) {
    Set<GinjectorBindings> visited = new LinkedHashSet<GinjectorBindings>();

    GinjectorBindings lastGinjector = null;
    while (ginjector != null) {
      if (!visited.add(ginjector)) {
        logger.log(Type.ERROR, PrettyPrinter.format(
          "Cycle detected in bindings for %s", key));
        for (GinjectorBindings visitedBindings : visited) {
          PrettyPrinter.log(logger, Type.ERROR, "  %s", visitedBindings);
        }
        return ginjector; // at this point, just return *something*
      }
      
      lastGinjector = ginjector;
      ginjector = linkedGinjector(ginjector.getBinding(key));
    }
    return lastGinjector;
  }
444371
def key_type(self, type_):
        """"""
        if not self.is_mapping(type_):
            raise TypeError(
                'Type "%s" is not "mapping" container' %
                str(type_))
        return self.__find_xxx_type(
            type_,
            self.key_type_index,
            self.key_type_typedef,
            'container_key_type')
767108
private static void getKeyInfo(UResourceBundle keyInfoRes) {
        Set<String> _deprecatedKeys = new LinkedHashSet<String>();
        Map<String, ValueType> _valueTypes = new LinkedHashMap<String, ValueType>();
        for (UResourceBundleIterator keyInfoIt = keyInfoRes.getIterator(); keyInfoIt.hasNext();) {
            UResourceBundle keyInfoEntry = keyInfoIt.next();
            String key = keyInfoEntry.getKey();
            KeyInfoType keyInfo = KeyInfoType.valueOf(key);
            for (UResourceBundleIterator keyInfoIt2 = keyInfoEntry.getIterator(); keyInfoIt2.hasNext();) {
                UResourceBundle keyInfoEntry2 = keyInfoIt2.next();
                String key2 = keyInfoEntry2.getKey();
                String value2 = keyInfoEntry2.getString();
                switch (keyInfo) {
                case deprecated:
                    _deprecatedKeys.add(key2);
                    break;
                case valueType:
                    _valueTypes.put(key2, ValueType.valueOf(value2));
                    break;
                }
            }
        }
        DEPRECATED_KEYS = Collections.unmodifiableSet(_deprecatedKeys);
        VALUE_TYPES = Collections.unmodifiableMap(_valueTypes);
    }
123702
def get_keyboard_mapping(self, first_keycode, count):
        """"""
        r = request.GetKeyboardMapping(display = self.display,
                                       first_keycode = first_keycode,
                                       count = count)
        return r.keysyms
816255
def __grabHotkeys(self):
        
        c = self.app.configManager
        hotkeys = c.hotKeys + c.hotKeyFolders

        # Grab global hotkeys in root window
        for item in c.globalHotkeys:
            if item.enabled:
                self.__enqueue(self.__grabHotkey, item.hotKey, item.modifiers, self.rootWindow)
                if self.__needsMutterWorkaround(item):
                    self.__enqueue(self.__grabRecurse, item, self.rootWindow, False)

        # Grab hotkeys without a filter in root window
        for item in hotkeys:
            if item.get_applicable_regex() is None:
                self.__enqueue(self.__grabHotkey, item.hotKey, item.modifiers, self.rootWindow)
                if self.__needsMutterWorkaround(item):
                    self.__enqueue(self.__grabRecurse, item, self.rootWindow, False)

        self.__enqueue(self.__recurseTree, self.rootWindow, hotkeys)