switch to 'bindings' d511673
967692
@Override
    public JPAPuId[] getExtendedContextPuIds(Collection<InjectionBinding<?>> injectionBindings,
                                             String ejbName,
                                             Set<String> persistenceRefNames,
                                             List<Object> bindingList)
    {
        return JPAExEntityManager.getExtendedContextPuIds(injectionBindings, ejbName, persistenceRefNames, bindingList); // F743-30682
    }
1017885
def _bind(self, args, kwds):
    """"""
    bindings = dict(kwds)
    for i, arg in enumerate(args):
      bindings[i + 1] = arg
    used = {}
    ancestor = self.ancestor
    if isinstance(ancestor, ParameterizedThing):
      ancestor = ancestor.resolve(bindings, used)
    filters = self.filters
    if filters is not None:
      filters = filters.resolve(bindings, used)
    unused = []
    for i in xrange(1, 1 + len(args)):
      if i not in used:
        unused.append(i)
    if unused:
      raise datastore_errors.BadArgumentError(
          'Positional arguments %s were given but not used.' %
          ', '.join(str(i) for i in unused))
    return self.__class__(kind=self.kind, ancestor=ancestor,
                          filters=filters, orders=self.orders,
                          app=self.app, namespace=self.namespace,
                          default_options=self.default_options,
                          projection=self.projection, group_by=self.group_by)
1003145
def load_abort_and_exit_bindings():
    
    registry = Registry()
    handle = registry.add_binding

    @handle(Keys.ControlC)
    def _(event):
        " Abort when Control-C has been pressed. "
        event.cli.abort()

    @Condition
    def ctrl_d_condition(cli):
        """ Ctrl-D binding is only active when the default buffer is selected
        and empty. """
        return (cli.current_buffer_name == DEFAULT_BUFFER and
                not cli.current_buffer.text)

    handle(Keys.ControlD, filter=ctrl_d_condition)(get_by_name('end-of-file'))

    return registry
186613
def map_keys
      @keys_mapped = true
      bind_key($row_selector, 'toggle row selection'){ toggle_row_selection() }
      bind_key(KEY_ENTER, 'toggle expanded state') { toggle_expanded_state() }
      bind_key(?o, 'toggle expanded state') { toggle_expanded_state() }
      bind_key(?f, 'first row starting with char'){ ask_selection_for_char() }
      bind_key(?\M-v, 'one key selection toggle'){ @one_key_selection = !@one_key_selection }
      bind_key(?O, 'expand children'){ expand_children() }
      bind_key(?X, 'collapse children'){ collapse_children() }
      bind_key(?>, :scroll_right)
      bind_key(?<, :scroll_left)
      # TODO
      bind_key(?x, 'collapse parent'){ collapse_parent() }
      bind_key(?p, 'goto parent'){ goto_parent() }
      require 'canis/core/include/deprecated/listbindings'
      #ListBindings.bindings
      bindings
    end
837633
def get_sync_binding_cmds(self, switch_bindings, expected_bindings):
        
        switch_cmds = list()

        # Update any necessary switch interface ACLs
        bindings_to_delete = switch_bindings - expected_bindings
        bindings_to_add = expected_bindings - switch_bindings
        for intf, acl, direction in bindings_to_delete:
            switch_cmds.extend(['interface %s' % intf,
                                'no ip access-group %s %s' %
                                (acl, direction),
                                'exit'])
        for intf, acl, direction in bindings_to_add:
            switch_cmds.extend(['interface %s' % intf,
                                'ip access-group %s %s' % (acl, direction),
                                'exit'])
        return switch_cmds
454777
function () {
                    if (this.$initialized) {
                        return;
                    }

                    var $ = this.$,
                        bindingCreator = this.$bindingCreator,
                        bindingAttributes = this.$bindingAttributes,
                        bindingDefinitions,
                        bindingAttribute,
                        value,
                        key;

                    // FIXME: resolve dependencies between bindings and loop in the correct order
                    // e.g. view="{{product.view}}" needs product

                    // Resolve bindings and events
                    for (key in bindingAttributes) {
                        if (bindingAttributes.hasOwnProperty(key)) {
                            bindingAttribute = bindingAttributes[key];
                            if (bindingAttribute) {
                                value = bindingAttribute.value;
                                bindingDefinitions = bindingAttribute.bindingDefinitions;
                                $[key] = bindingCreator.evaluate(value, this, key, bindingDefinitions);
                            } else {
                                value = $[key];
                                bindingDefinitions = null;
                            }
                        }
                    }

                    if (this.$errorAttribute && this.$bindings[this.$errorAttribute]) {
                        var b = this.$bindings[this.$errorAttribute][0], errorBinding;
                        if (b.$.path.length > 1) {
                            var path = b.$.path.slice(), attrKey = path.pop().name;
                            path = path.concat(bindingCreator.parsePath("errors()." + attrKey));

                            errorBinding = bindingCreator.create({
                                type: 'oneWay',
                                path: path
                            }, this, "$error");
                            if (errorBinding) {
                                $['$error'] = errorBinding.getValue();
                            }
                        }
                    }

                    this._initializeBindingsBeforeComplete();

                    this._initializationComplete();
                }
817502
def __bindings(self):
        """"""

        self.direction_choicectrl.Bind(wx.EVT_CHOICE, self.OnDirectionChoice)
        self.sec_checkboxctrl.Bind(wx.EVT_CHECKBOX, self.OnSecondaryCheckbox)
        self.pad_intctrl.Bind(EVT_INT, self.OnPadIntCtrl)
        self.labelsize_intctrl.Bind(EVT_INT, self.OnLabelSizeIntCtrl)
1359247
function extendBinding(binding, extension){
    /** @cut */ var info = basis.dev.getInfo(extension, 'map');

    binding.bindingId = bindingSeed++;

    for (var key in extension)
    {
      var def = null;
      var value = extension[key];

      // NOTE: check for Node, because first extendBinding invoke before Node class declared
      if ((Node && value instanceof Node) || basis.resource.isResource(value))
      {
        def = {
          events: 'satelliteChanged',
          getter: (function(key, satellite){
            var resource = typeof satellite == 'function' ? satellite : null;
            var init = function(node){
              init = false;

              if (resource)
              {
                satellite = resource();
                if (satellite instanceof Node == false)
                  return;
                resource = null;
              }

              node.setSatellite(key, satellite);

              /** @cut */ if (node.satellite[key] !== satellite)
              /** @cut */   basis.dev.warn('basis.ui.binding: implicit satellite `' + key + '` attach to owner failed');
            };
            return function(node){
              if (init)
                init(node);

              return resource || (node.satellite[key] ? node.satellite[key].element : null);
            };
          })(key, value)
        };
      }
      else
      {
        if (value)
        {
          if (typeof value == 'string')
            value = BINDING_PRESET.process(key, value);
          else
            // if value has bindingBridge means that it can update itself
            if (value.bindingBridge)
              value = basis.fn.$const(value);

          if (typeof value != 'object')
          {
            def = {
              getter: typeof value == 'function' ? value : basis.getter(value)
            };
          }
          else
            if (Array.isArray(value))
            {
              def = {
                events: value[0],
                getter: basis.getter(value[1])
              };
            }
            else
            {
              def = {
                events: value.events,
                getter: basis.getter(value.getter)
              };
            }
        }
      }

      /** @cut */ if (def && info && info.hasOwnProperty(key))
      /** @cut */   def.loc = info[key];

      binding[key] = def;
    }
  }
936642
void bindToBottomTab(BottomNavigationTab bottomNavigationTab) {
        // set initial bindings
        bottomNavigationTab.badgeView.clearPrevious();
        if (bottomNavigationTab.badgeItem != null) {
            // removing old reference
            bottomNavigationTab.badgeItem.setTextView(null);
        }
        bottomNavigationTab.setBadgeItem(this);
        setTextView(bottomNavigationTab.badgeView);

        // allow sub class to modify the things
        bindToBottomTabInternal(bottomNavigationTab);

        // make view visible because gone by default
        bottomNavigationTab.badgeView.setVisibility(View.VISIBLE);

        // set layout params based on gravity
        FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) bottomNavigationTab.badgeView.getLayoutParams();
        layoutParams.gravity = getGravity();
        bottomNavigationTab.badgeView.setLayoutParams(layoutParams);

        // if hidden hide
        if (isHidden()) {
            // if hide is called before the initialisation of bottom-bar this will handle that
            // by hiding it.
            hide();
        }
    }
273631
function bindToConsole (instance) {
  if (!instance) return
  if (!isBrowser) return

  const id = instance.__VUE_DEVTOOLS_UID__
  const index = consoleBoundInstances.indexOf(id)
  if (index > -1) {
    consoleBoundInstances.splice(index, 1)
  } else {
    consoleBoundInstances.pop()
  }

  consoleBoundInstances.unshift(id)
  for (var i = 0; i < 5; i++) {
    window['$vm' + i] = instanceMap.get(consoleBoundInstances[i])
  }
  window.$vm = instance
}
214843
def bind_download_buttons(cls):
        
        def on_click(ev):
            button_el = ev.target
            form_el = button_el.parent.parent.parent

            # this allows to use disabled <textearea>, which is normally not
            # sent
            content = form_el.get(selector="textarea")[0].text

            # change filename according to output
            suffix = form_el.name
            download_path = "as_file/%s.%s" % (cls.filename, suffix)
            form_el.action = join(settings.API_PATH, download_path)

            input_el = form_el.get(selector="input")[0]
            input_el.value = content

        for el in document.get(selector="button.output_download_button"):
            el.bind("click", on_click)
970355
def _bind(self):
        
        self._bind_as(self.settings.BIND_DN, self.settings.BIND_PASSWORD, sticky=True)
1278818
static void bindTabWithData(BottomNavigationItem bottomNavigationItem, BottomNavigationTab bottomNavigationTab, BottomNavigationBar bottomNavigationBar) {

        Context context = bottomNavigationBar.getContext();

        bottomNavigationTab.setLabel(bottomNavigationItem.getTitle(context));
        bottomNavigationTab.setIcon(bottomNavigationItem.getIcon(context));

        int activeColor = bottomNavigationItem.getActiveColor(context);
        int inActiveColor = bottomNavigationItem.getInActiveColor(context);

        if (activeColor != Utils.NO_COLOR) {
            bottomNavigationTab.setActiveColor(activeColor);
        } else {
            bottomNavigationTab.setActiveColor(bottomNavigationBar.getActiveColor());
        }

        if (inActiveColor != Utils.NO_COLOR) {
            bottomNavigationTab.setInactiveColor(inActiveColor);
        } else {
            bottomNavigationTab.setInactiveColor(bottomNavigationBar.getInActiveColor());
        }

        if (bottomNavigationItem.isInActiveIconAvailable()) {
            Drawable inactiveDrawable = bottomNavigationItem.getInactiveIcon(context);
            if (inactiveDrawable != null) {
                bottomNavigationTab.setInactiveIcon(inactiveDrawable);
            }
        }

        bottomNavigationTab.setItemBackgroundColor(bottomNavigationBar.getBackgroundColor());

        BadgeItem badgeItem = bottomNavigationItem.getBadgeItem();
        if (badgeItem != null) {
            badgeItem.bindToBottomTab(bottomNavigationTab);
        }
    }
450331
function initializeDirectiveBindings(scope, attrs, destination, bindings, directive) {
      var removeWatchCollection = [];
      var changes;
      forEach(bindings, function initializeBinding(definition, scopeName) {
        var attrName = definition.attrName,
        optional = definition.optional,
        mode = definition.mode, // @, =, or &
        lastValue,
        parentGet, parentSet, compare, removeWatch;

        switch (mode) {

          case '@':
            if (!optional && !hasOwnProperty.call(attrs, attrName)) {
              destination[scopeName] = attrs[attrName] = void 0;
            }
            attrs.$observe(attrName, function(value) {
              if (isString(value)) {
                var oldValue = destination[scopeName];
                recordChanges(scopeName, value, oldValue);
                destination[scopeName] = value;
              }
            });
            attrs.$$observers[attrName].$$scope = scope;
            lastValue = attrs[attrName];
            if (isString(lastValue)) {
              // If the attribute has been provided then we trigger an interpolation to ensure
              // the value is there for use in the link fn
              destination[scopeName] = $interpolate(lastValue)(scope);
            } else if (isBoolean(lastValue)) {
              // If the attributes is one of the BOOLEAN_ATTR then Angular will have converted
              // the value to boolean rather than a string, so we special case this situation
              destination[scopeName] = lastValue;
            }
            break;

          case '=':
            if (!hasOwnProperty.call(attrs, attrName)) {
              if (optional) break;
              attrs[attrName] = void 0;
            }
            if (optional && !attrs[attrName]) break;

            parentGet = $parse(attrs[attrName]);
            if (parentGet.literal) {
              compare = equals;
            } else {
              compare = function simpleCompare(a, b) { return a === b || (a !== a && b !== b); };
            }
            parentSet = parentGet.assign || function() {
              // reset the change, or we will throw this exception on every $digest
              lastValue = destination[scopeName] = parentGet(scope);
              throw $compileMinErr('nonassign',
                  "Expression '{0}' in attribute '{1}' used with directive '{2}' is non-assignable!",
                  attrs[attrName], attrName, directive.name);
            };
            lastValue = destination[scopeName] = parentGet(scope);
            var parentValueWatch = function parentValueWatch(parentValue) {
              if (!compare(parentValue, destination[scopeName])) {
                // we are out of sync and need to copy
                if (!compare(parentValue, lastValue)) {
                  // parent changed and it has precedence
                  destination[scopeName] = parentValue;
                } else {
                  // if the parent can be assigned then do so
                  parentSet(scope, parentValue = destination[scopeName]);
                }
              }
              return lastValue = parentValue;
            };
            parentValueWatch.$stateful = true;
            if (definition.collection) {
              removeWatch = scope.$watchCollection(attrs[attrName], parentValueWatch);
            } else {
              removeWatch = scope.$watch($parse(attrs[attrName], parentValueWatch), null, parentGet.literal);
            }
            removeWatchCollection.push(removeWatch);
            break;

          case '<':
            if (!hasOwnProperty.call(attrs, attrName)) {
              if (optional) break;
              attrs[attrName] = void 0;
            }
            if (optional && !attrs[attrName]) break;

            parentGet = $parse(attrs[attrName]);

            destination[scopeName] = parentGet(scope);

            removeWatch = scope.$watch(parentGet, function parentValueWatchAction(newParentValue) {
              var oldValue = destination[scopeName];
              recordChanges(scopeName, newParentValue, oldValue);
              destination[scopeName] = newParentValue;
            }, parentGet.literal);

            removeWatchCollection.push(removeWatch);
            break;

          case '&':
            // Don't assign Object.prototype method to scope
            parentGet = attrs.hasOwnProperty(attrName) ? $parse(attrs[attrName]) : noop;

            // Don't assign noop to destination if expression is not valid
            if (parentGet === noop && optional) break;

            destination[scopeName] = function(locals) {
              return parentGet(scope, locals);
            };
            break;
        }
      });

      function recordChanges(key, currentValue, previousValue) {
        if (isFunction(destination.$onChanges) && currentValue !== previousValue) {
          // If we have not already scheduled the top level onChangesQueue handler then do so now
          if (!onChangesQueue) {
            scope.$$postDigest(flushOnChangesQueue);
            onChangesQueue = [];
          }
          // If we have not already queued a trigger of onChanges for this controller then do so now
          if (!changes) {
            changes = {};
            onChangesQueue.push(triggerOnChangesHook);
          }
          // If the has been a change on this property already then we need to reuse the previous value
          if (changes[key]) {
            previousValue = changes[key].previousValue;
          }
          // Store this change
          changes[key] = {previousValue: previousValue, currentValue: currentValue};
        }
      }

      function triggerOnChangesHook() {
        destination.$onChanges(changes);
        // Now clear the changes so that we schedule onChanges when more changes arrive
        changes = undefined;
      }

      return removeWatchCollection.length && function removeWatches() {
        for (var i = 0, ii = removeWatchCollection.length; i < ii; ++i) {
          removeWatchCollection[i]();
        }
      };
    }
1317768
function (bindingDef, targetScope, attrKey, context) {
            var path = bindingDef.path;
            var pathElement = path[0];

            var scope;
            var searchScope = targetScope;
            if (pathElement.type != Binding.TYPE_FNC && attrKey == pathElement.name) {
                searchScope = searchScope.$parentScope;
            }

            if (pathElement.type == Binding.TYPE_FNC) {
                scope = searchScope.getScopeForFncName(pathElement.name);
            } else {
                scope = searchScope.getScopeForKey(pathElement.name);
            }

            if (scope) {
                if (bindingDef.type !== "static") {
                    var cb;
                    if (_.isFunction(attrKey)) {
                        cb = attrKey;
                    }

                    var twoWay = (bindingDef.type == Binding.TYPE_TWOWAY);

                    var options = {
                        scope: scope,
                        path: path,
                        parent: bindingDef.parent,
                        target: targetScope,
                        twoWay: twoWay,
                        context: context,
                        bindingCreator: this
                    };

                    if (twoWay) {
                        var fncName,
                            fncScope;
                        if (bindingDef.transform && bindingDef.transform.length) {
                            fncName = bindingDef.transform[0].name;
                            fncScope = searchScope.getScopeForFncName(fncName);
                            if (fncScope && fncScope[fncName] instanceof Function) {
                                options.transform = fncScope[fncName];
                                options.transformScope = fncScope;
                            }
                        }

                        if (bindingDef.transformBack && bindingDef.transformBack.length) {
                            fncName = bindingDef.transformBack[0].name;
                            fncScope = searchScope.getScopeForFncName(fncName);
                            if (fncScope && fncScope[fncName] instanceof Function) {
                                options.transformBack = fncScope[fncName];
                                options.transformBackScope = fncScope;
                            }
                        }
                    }

                    if (cb) {
                        options.callback = cb;
                    } else {
                        options.targetKey = attrKey;
                    }

                    return new Binding(options);
                } else {
                    var par,
                        newPath = [];

                    function resolvePath(scope, path) {
                        return scope.get(resolveParameter(path));
                    }

                    function resolveParameter(path) {
                        var pathElement,
                            first,
                            scope,
                            newPath = [],
                            parameter = [];
                        for (var i = 0; i < path.length; i++) {
                            pathElement = path[i];
                            if (_.isObject(pathElement)) {
                                if (pathElement.type === "fnc") {
                                    parameter = [];
                                    for (var j = 0; j < pathElement.parameter.length; j++) {
                                        par = pathElement.parameter[j];
                                        // if it's a path
                                        if (_.isArray(par)) {
                                            first = par[0];
                                            // TODO: check targetscope first
                                            if (first.type === "var") {
                                                scope = searchScope.getScopeForKey(first.name);
                                            } else if (first.type === "fnc") {
                                                scope = searchScope.getScopeForKey(first.name);
                                            }
                                            if (scope) {
                                                par = resolvePath(scope, par);
                                            }
                                        }
                                        parameter.push(par);
                                    }

                                }
                                newPath.push({
                                    index: pathElement.index,
                                    type: pathElement.type,
                                    name: pathElement.name,
                                    parameter: parameter
                                })
                            }
                        }

                        return newPath;
                    }

                    return scope.get(resolveParameter(bindingDef.path));
                }
            } else {
                throw new Error("Couldn't find scope for " + pathElement.name);
            }

        }
996789
def get_bindings(self):
        
        path = Client.urls['all_bindings']
        bindings = self._call(path, 'GET')
        return bindings
327508
function executeBinding(binding) {
			var invocation = binding.invocation;
			if (invocation) {
				var command = binding.command;
				if (typeof(command.hrefCallback) === 'function') {
					var href = command.hrefCallback.call(invocation.handler || window, invocation);
					if (href.then){
						href.then(function(l){
							window.open(urlModifier(l));
						});
					} else {
						// We assume window open since there's no link gesture to tell us what to do.
						window.open(urlModifier(href));
					}
					return true;
				} else if (invocation.commandRegistry) {
					// See https://bugs.eclipse.org/bugs/show_bug.cgi?id=411282
					invocation.commandRegistry._invoke(invocation);
					return true;
				} else if (command.onClick || command.callback) {
					// TODO: what is this timeout for?
					window.setTimeout(function() {
						(command.onClick || command.callback).call(invocation.handler || window, invocation);
					}, 0);
					return true;
				}
			}
			return false;
		}