Lists reserved bindings.
16751
def get_reserved_bindings(vlan_id, instance_id, switch_ip=None,
                          port_id=None):
    """"""
    LOG.debug("get_reserved_bindings() called")
    if port_id:
        return _lookup_all_nexus_bindings(vlan_id=vlan_id,
                                          switch_ip=switch_ip,
                                          instance_id=instance_id,
                                          port_id=port_id)
    elif switch_ip:
        return _lookup_all_nexus_bindings(vlan_id=vlan_id,
                                          switch_ip=switch_ip,
                                          instance_id=instance_id)
    else:
        return _lookup_all_nexus_bindings(vlan_id=vlan_id,
                                          instance_id=instance_id)
829010
def get_keybindings(self, mode):
        
        globalmaps, modemaps = {}, {}
        bindings = self._bindings
        # get bindings for mode `mode`
        # retain empty assignations to silence corresponding global mappings
        if mode in bindings.sections:
            for key in bindings[mode].scalars:
                value = bindings[mode][key]
                if isinstance(value, list):
                    value = ','.join(value)
                modemaps[key] = value
        # get global bindings
        # ignore the ones already mapped in mode bindings
        for key in bindings.scalars:
            if key not in modemaps:
                value = bindings[key]
                if isinstance(value, list):
                    value = ','.join(value)
                if value and value != '':
                    globalmaps[key] = value
        # get rid of empty commands left in mode bindings
        for k, v in list(modemaps.items()):
            if not v:
                del modemaps[k]

        return globalmaps, modemaps
298239
def ListOf(cls, **kwargs):
    """"""

    def _list_load(value):
        return [cls.load(d) for d in value]

    return Property(types=list, load=_list_load, default=list, **kwargs)
847427
@Override
    public NamingEnumeration<Binding> listBindings(String s) throws NamingException {
        return listBindings(newCompositeName(s));
    }
1051160
def list_bindings_for_vhost(self, vhost):
        
        return self._api_get('/api/bindings/{}'.format(
            urllib.parse.quote_plus(vhost)
        ))
1261837
@Override
  public <T> List<Binding<T>> bindings(Key<T> key)
  {
    BindingSet<T> set = (BindingSet) _bindingSetMap.get(key.rawClass());

    if (set != null) {
      return set.bindings(key);
    }
    else {
      return Collections.EMPTY_LIST;
    }
  }
503689
protected void applyContext(AbstractListBinding binding, Map context) {
        if (context.containsKey(SELECTABLE_ITEMS_KEY)) {
            binding.setSelectableItems(decorate(context.get(SELECTABLE_ITEMS_KEY), selectableItems));
        } else if (selectableItems != null) {
            binding.setSelectableItems(selectableItems);
        }
        if (context.containsKey(COMPARATOR_KEY)) {
            binding.setComparator((Comparator) decorate(context.get(COMPARATOR_KEY), comparator));
        } else if (comparator != null) {
            binding.setComparator(comparator);
        }
        if (context.containsKey(FILTER_KEY)) {
            binding.setFilter((Constraint) decorate(context.get(FILTER_KEY), filter));
        } else if (filter != null) {
            binding.setFilter(filter);
        }
    }
605119
def bind(self, fn: Callable[[Any], 'List']) -> 'List':
        
        return List.concat(self.map(fn))
620948
def bindings(self):
        
        if self._bindings is None:
            self._bindings = BindingList(self._version, service_sid=self._solution['sid'], )
        return self._bindings
996789
def get_bindings(self):
        
        path = Client.urls['all_bindings']
        bindings = self._call(path, 'GET')
        return bindings
876581
public static <E> Bindable<List<E>> listOf(Class<E> elementType) {
		return of(ResolvableType.forClassWithGenerics(List.class, elementType));
	}
1102202
function getBindingsFromTemplateProperties(oElement) {
		var aPropertiesKeys = Object.keys(oElement.getMetadata().getAllProperties());

		return aPropertiesKeys
			.filter(function (sPropertyName) {
				return sPropertyName in oElement.mBindingInfos;
			})
			.reduce(function (aBindings, sPropertyName) {
				return aBindings.concat(
					flattenBindingsFromTemplate(
						oElement.mBindingInfos[sPropertyName]
					)
				);
			}, []);
	}
614367
private List<String> binds() {
    final ImmutableList.Builder<String> binds = ImmutableList.builder();
    for (final Map.Entry<String, String> entry : job.getVolumes().entrySet()) {
      final String path = entry.getKey();
      final String source = entry.getValue();
      if (Strings.isNullOrEmpty(source)) {
        continue;
      }
      binds.add(source + ":" + path);
    }
    return binds.build();
  }
860545
public function getBindings() {
        $keys = func_num_args() < 1 ? array_keys($this->bindings) : func_get_args();
        $args = [];
        foreach ($keys as $item) {
            if (!array_key_exists($item, $this->bindings)) {
                continue;
            }
            $args = array_merge($args, $this->bindings[$item]);
        }
        return $args;
    }
985371
def get_applicable_values(self):
        """"""
        return [v for v in self._values if v.is_active and not v.is_all_results]
627869
private function _checkBinds()
    {
        if ($this->_fetch_sty!=\PDO::FETCH_BOUND) {
            return;
        }
        foreach ($this->_binds as $key => &$value) {
            if (is_numeric($key)) {
                $key --;
            } else {
                $key = strtoupper($key);
            }
            if (!array_key_exists($key, $this->_current)) {
                continue;
            }
            $value = $this->_current[$key];
        }
    }
408609
function getPropertiesAndBindings( root, libs, com, indent ) {
  // Attributes can have post initialization, especially for data bindings.
  var postInit = {};
  var hasPostInit = false;
  var key,
      val,
      values;
  var bindings;
  var slots;
  for ( key in root.attribs ) {
    if ( key.charAt( 0 ) == '$' ) {
      // All the attributes that start with a '$' are used as args attributes.
      val = root.attribs[key];
      com.prop[key.substr( 1 )] = JSON.stringify( val );
    }
    else if ( key.substr( 0, 5 ) == 'intl:' ) {
      // Internationalization.
      val = root.attribs[key];
      com.prop[key.substr( 5 )] = "APP._(" + JSON.stringify( val ) + ")";
    }
    else if ( key.substr( 0, 5 ) == 'bind:' ) {
      // Syntaxe :
      // <bind> := <bind-item> <bind-next>*
      // <bind-next> := "," <bind-item>
      // <bind-item> := <widget-name> <attribute>? <value>?
      // <widget-name> := /[$a-zA-Z_-][$0-9a-zA-Z_-]+/
      // <attribute> := ":" <attrib-name>
      // <attrib-name> := /[$a-zA-Z_-][$0-9a-zA-Z_-]+/
      // <value> := "=" <data>
      // <data> := "true" | "false" | "null" | <number> | <string>
      //
      // @example
      // <wdg:checkbox bind:value="btn1:action" />
      // <wdg:checkbox bind:value="btn1:action, btn2, action=false" />
      if ( typeof postInit[key.substr( 5 )] === 'undefined' ) {
        postInit[key.substr( 5 )] = {};
      }
      postInit[key.substr( 5 )].B = parseBinding(root.attribs[key]);
      hasPostInit = true;
    }
    else if ( key.substr( 0, 5 ) == 'slot:' ) {
      // @example
      // <wdg:button slot:action="removeOrder" />
      // <wdg:button slot:action="removeOrder, changePage" />
      // <wdg:button slot:action="my-module:my-function" />
      values = root.attribs[key].split( "," );
      key = key.substr( 5 );
      if ( typeof postInit[key] === 'undefined' ) {
        postInit[key] = {};
      }
      slots = [ ];
      values.forEach( function( val ) {
        // Before the colon (:) there is the module name. After, there
        // is the function  name. If there is no colon,  `APP` is used
        // as module.
        val = val.split( ':' );
        if ( val.length < 2 ) {
          slots.push(val[0].trim( ));
        } else {
          slots.push(val.map( String.trim ));
          libs.require(val[0]);
        }
      });
      postInit[key].S = slots;
      hasPostInit = true;
    }
    else {
      com.attr[key] = root.attribs[key];
    }
  }

  if ( hasPostInit ) {
    libs.addPostInitJS( "        W.bind('" + com.attr.id + "'," + JSON.stringify( postInit ) + ");" );
  }
}