Returns true if the user has configured a binding for this reference.
178083
private void setBindingName() // d681743
    throws InjectionException
    {
        Map<String, String> ejbRefBindings = ivNameSpaceConfig.getEJBRefBindings();
        if (ejbRefBindings != null)
        {
            ivBindingName = ejbRefBindings.get(getJndiName());

            if (ivBindingName != null && ivBindingName.equals(""))
            {
                ivBindingName = null;
                Tr.warning(tc, "EJB_BOUND_TO_EMPTY_STRING_CWNEN0025W");
                if (isValidationFailable()) // fail if enabled       F743-14449
                {
                    InjectionConfigurationException icex = new InjectionConfigurationException
                                    ("The " + getJndiName() + " EJB reference in the " + ivModule +
                                     " module of the " + ivApplication + " application has been" +
                                     " bound to the empty string in the global Java Naming and Directory Interface (JNDI) namespace.");
                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        Tr.exit(tc, "resolve : " + icex);
                    throw icex;
                }
            }
        }
    }
356310
protected function bindResult()/*# : bool */
    {
        // get fields first
        if (!$this->getFields()) {
            return false;
        }

        // bind values
        if (null === $this->vals) {
            $this->vals = array_fill(0, count($this->cols), null);

            $refs = [];
            foreach ($this->vals as $i => &$f) {
                $refs[$i] = &$f;
            }
            call_user_func_array([$this->statement, 'bind_result'], $refs);
        }
        return true;
    }
1245349
public boolean isSet(String propName) {
        if (propName.equals("roles")) {
            return isSetRoles();
        }
        if (propName.equals("entitlements")) {
            return isSetEntitlements();
        }
        if (propName.equals("entitlementCheckResult")) {
            return isSetEntitlementCheckResult();
        }
        return false;
    }
1277278
def bind_handler(self, svc_ref):
        
        if svc_ref in self._bound_references:
            # Already bound service
            return False

        # Get the service
        handler = self._context.get_service(svc_ref)

        # Get its name space
        namespace = handler.get_namespace()
        commands = []

        # Register all service methods directly
        for command, method in handler.get_methods():
            self.register_command(namespace, command, method)
            commands.append(command)

        # Store the reference
        self._bound_references[svc_ref] = handler
        self._reference_commands[svc_ref] = (namespace, commands)
        return True
535011
public boolean isTrue(Configuration configuration) {
        for (int i = 0; i < this.variables.size(); ++i) {
            Variable variable = this.variables.get(i);
            if (configuration.valueAt(variable.getIndex()) == 1 && !this.negatedFlags.get(i))
                return true;
            if (configuration.valueAt(variable.getIndex()) == 0 && this.negatedFlags.get(i))
                return true;
        }

        return false;
    }
937089
private void checkBindings(EnhancedAnnotation<T> annotatedAnnotation) {
        Set<Annotation> bindings = annotatedAnnotation.getMetaAnnotations(Qualifier.class);
        if (bindings.size() > 0) {
            for (Annotation annotation : bindings) {
                if (!annotation.annotationType().equals(Named.class)) {
                    throw MetadataLogger.LOG.qualifierOnStereotype(annotatedAnnotation);
                }
            }
        }
    }
352169
protected boolean shouldBindCollectionWithForeignKey(ToMany property) {
        return ((property instanceof org.grails.datastore.mapping.model.types.OneToMany) && property.isBidirectional() ||
                !shouldCollectionBindWithJoinColumn(property)) &&
                !Map.class.isAssignableFrom(property.getType()) &&
                !(property instanceof ManyToMany) &&
                !(property instanceof Basic);
    }
1326488
public boolean bindToVariable(VariableRef ref) {
        String name = ref.getName();
        Variable var = getDeclaredVariable(name);
        
        if (var != null) {
            ref.setType(null);
            ref.setVariable(var);
            mVariableRefs.add(ref);
            return true;
        }
        else {
            return false;
        }
    }
226747
@Override
  public void bind()
  {
    if (_ownerProvider == null) {
      _ownerBinding.bind();
      
      _ownerProvider = _ownerBinding.provider(); 

      _program = _manager.program(_method.getParameters());
    }
  }
634847
private void initRegisteredBindings() {
        
        Enumeration<URL> bindingsConfiguration;
        try {
            bindingsConfiguration = ClassLoaderUtils.getClassLoader().getResources("META-INF/bindings.xml");
        } catch (IOException e) {
            throw new IllegalStateException("Error registering bindings: " + e.getMessage(), e);
        }

        registerConfigurations(bindingsConfiguration);
    }
1319329
function (binding) {
    var historyBinding = getHistoryBinding(binding);
    var redo = historyBinding.get('redo');
    return !!redo && !redo.isEmpty();
  }
1042919
public boolean isSet(String propName) {
        if (propName.equals("method")) {
            return isSetMethod();
        }
        if (propName.equals("object")) {
            return isSetObject();
        }
        if (propName.equals("attribute")) {
            return isSetAttribute();
        }
        return false;
    }
1101513
public boolean isSet(@NonNull NamedOption option) {
      if (option.isBoolean()) {
         return option.getValue() != null && option.<Boolean>getValue();
      }

      return option.getValue() != null;
   }
626425
def bind(self, cls, instance):
        """"""
        self._check_class(cls)
        self._bindings[cls] = lambda: instance
        logger.debug('Bound %s to an instance %s', cls, instance)
        return self
631293
function(oldObserved, newObserveSet, name, onchanged) {
            if (oldObserved[name]) {
                // After binding is set up, values
                // in `oldObserved` will be unbound. So if a name
                // has already be observed, remove from `oldObserved`
                // to prevent this.
                delete oldObserved[name];
            } else {
                // If current name has not been observed, listen to it.
                var obEv = newObserveSet[name];
                obEv.obj.bind(obEv.event, onchanged);
            }
        }
234686
public static boolean isArrayBind(Map<String, ParameterBindingDTO> bindValues)
  {
    if (bindValues == null || bindValues.size() == 0)
    {
      return false;
    }
    ParameterBindingDTO bindSample = bindValues.values().iterator().next();
    return bindSample.getValue() instanceof List;
  }
914909
private function registerBindings()
    {
        $this->app->bind('society.isInstalled', function ($app) {
            return
                file_exists(base_path('.env')) &&
                file_exists(storage_path('app/installed')) &&
                Schema::hasTable('migrations');
        });
    }