Returns true if brand is satisfied, false if brand is not satisfied, or null if brand prototype could not be found.
515857
function hasBrand(value, brand) {
	var ctor = lookupPath(brand, function() { return null })
	if (!ctor || typeof ctor !== 'object')
		return null;
	var proto = lookupObject(ctor.key).propertyMap.get('prototype')
	if (!proto || !proto.value || typeof proto.value !== 'object')
		return null;
	while (value && typeof value === 'object') {
		if (value.key === proto.value.key)
			return true
		value = lookupObject(value.key).prototype
	}
	return false;
}
606410
protected final boolean isSatisfied(AnalyzedToken aToken,
      Map<String, List<String>> uFeatures) {

    if (allFeatsIn && equivalencesMatched.isEmpty()) {
      return false;
    }
    if (uFeatures == null) {
      throw new RuntimeException("isSatisfied called without features being set");
    }
    unificationFeats = uFeatures;

    boolean unified = true;
    if (allFeatsIn) {
      unified = checkNext(aToken, uFeatures);
    } else {
      while (equivalencesMatched.size() <= tokCnt) {
        equivalencesMatched.add(new ConcurrentHashMap<>());
      }
      for (Map.Entry<String, List<String>> feat : uFeatures.entrySet()) {
        List<String> types = feat.getValue();
        if (types == null || types.isEmpty()) {
          types = equivalenceFeatures.get(feat.getKey());
        }
        for (String typeName : types) {
          PatternToken testElem = equivalenceTypes
              .get(new EquivalenceTypeLocator(feat.getKey(), typeName));
          if (testElem == null) {
            return false;
          }
          if (testElem.isMatched(aToken)) {
            if (!equivalencesMatched.get(tokCnt).containsKey(feat.getKey())) {
              Set<String> typeSet = new HashSet<>();
              typeSet.add(typeName);
              equivalencesMatched.get(tokCnt).put(feat.getKey(), typeSet);
            } else {
              equivalencesMatched.get(tokCnt).get(feat.getKey()).add(typeName);
            }
          }
        }
        unified = equivalencesMatched.get(tokCnt).containsKey(feat.getKey());
        if (!unified) {
          equivalencesMatched.remove(tokCnt);
          break;
        }
      }
      if (unified) {
        if (tokCnt == 0 || tokSequence.isEmpty()) {
          tokSequence.add(new AnalyzedTokenReadings(aToken, 0));
          List<Map<String, Set<String>>> equivList = new ArrayList<>();
          equivList.add(equivalencesMatched.get(tokCnt));
          tokSequenceEquivalences.add(equivList);
        } else {
          tokSequence.get(0).addReading(aToken);
          tokSequenceEquivalences.get(0).add(equivalencesMatched.get(tokCnt));
        }
        tokCnt++;
      }
    }
    return unified;
  }
195511
public boolean isInstanceOfTag(Tag tag) {
      return tag != null && getTag().filter(t -> t.isInstance(tag)).isPresent();
   }
1088965
public boolean satisfied( PropertySet properties)
    {
    String property = getProperty();
    return property == null || properties.contains( property);
    }
1367706
private boolean satisfied(final CLClause c) {
        if (c.satisfied()) { return true; }
        for (int i = 0; i < c.lits().size(); i++) {
            if (val(c.lits().get(i)) == VALUE_TRUE) {
                if (this.level == 0) { c.setSatisfied(true); }
                return true;
            }
        }
        return false;
    }
588878
@Override
    public final boolean satisfiedForFlowOrdering(final FilterOutcomes outcomes) {
        if (isAlwaysSatisfiedRequirement()) {
            return true;
        }

        final ComponentRequirement componentRequirement = _hasComponentRequirement.getComponentRequirement();
        if (componentRequirement == null) {
            return true;
        }

        final Collection<FilterOutcome> dependencies = componentRequirement.getProcessingDependencies();
        for (final FilterOutcome filterOutcome : dependencies) {
            final boolean contains = outcomes.contains(filterOutcome);
            if (!contains) {
                return false;
            }
        }

        return componentRequirement.isSatisfied(null, outcomes);
    }
592386
private boolean isValidConcept(final String concept, final Double score) {
    return !StringUtils.isBlank(concept)
           || score != null;
  }
1230504
@Override
    public final boolean satisfiedForConsume(final FilterOutcomes outcomes, final InputRow row) {
        final boolean satisfiedOutcomesForConsume =
                satisfiedOutcomesForConsume(_hasComponentRequirement, row, outcomes);
        if (!satisfiedOutcomesForConsume) {
            return false;
        }
        return satisfiedInputsForConsume(row, outcomes);
    }
30948
function areTermsMatching (buyerTerms, sellerTerms) {

  if (buyerTerms.maxPrice >= sellerTerms.minPrice &&
      buyerTerms.maxLock >= sellerTerms.minLock &&
      buyerTerms.minNumberOfSellers <= sellerTerms.maxNumberOfSellers &&
      buyerTerms.maxContractFeePerKb >= sellerTerms.minContractFeePerKb
  ) {
    return true
  } else {
    return false
  }
}
476117
def is_satisfied_by(self, candidate: Any, **kwds: Any) -> bool:
        """"""
        candidate_name = self._candidate_name
        context = self._context
        if context:
            if candidate_name in kwds:
                raise ValueError(f"Candidate name '{candidate_name}' must "
                                 "not be given as keyword.")
            context.update(kwds)
        context[candidate_name] = candidate
        try:
            code = self._code
        except AttributeError:
            self._code = code = compile(self._ast_expr, '<str>', mode='eval')
        return eval(code, context)
595981
def _has_example(self, label):
        """"""
        if label in self._raw_examples:
            return True
        else:
            for field in self.all_fields:
                dt, _ = unwrap_nullable(field.data_type)
                if not is_user_defined_type(dt) and not is_void_type(dt):
                    continue
                if label == field.name:
                    return True
            else:
                return False
828480
protected function validateProductClass()
    {
        $id = $this->getUpdatingId();

        if ($id === false) {
            return null;
        }

        $data = $this->product_class->get($id);

        if (empty($data)) {
            $this->setErrorUnavailable('update', $this->translation->text('Product class'));
            return false;
        }

        $this->setUpdating($data);
        return true;
    }
1342128
def satisfiesShapeNot(cntxt: Context, n: Node, se: ShExJ.ShapeNot, _: DebugContext) -> bool:
    
    return not satisfies(cntxt, n, se.shapeExpr)
1303516
public boolean satisfied( PropertySet propertySet)
    {
    boolean isSatisfied;
    Iterator<String> properties;
    
    for( properties = getProperties(),
           isSatisfied = !properties.hasNext();

         !isSatisfied
           && properties.hasNext();

         isSatisfied = propertySet.contains( properties.next()));
    
    return isSatisfied;
    }
63244
public void setBrand(boolean _brand) {
		if (_brand) {
			AddResourcesListener.setFontAwesomeVersion(5, this);
		}
		getStateHelper().put(PropertyKeys.brand, _brand);
	}
1162726
public function isEntrySuffixed()
    {
        $oManufacturer = oxNew(\OxidEsales\Eshop\Application\Model\Manufacturer::class);
        if ($oManufacturer->load($this->getEditObjectId())) {
            return (bool) $oManufacturer->oxmanufacturers__oxshowsuffix->value;
        }
    }
917466
boolean mark(ProtoType type) {
    if (type == null) throw new NullPointerException("type == null");
    if (identifierSet.excludes(type)) return false;
    return types.add(type);
  }