Semantics for a mandatory feature.
A mandatory feature is selected iff its parent is selected.
@param Feature $feature
@return callable
336434
private static function mandatory($feature) {
        if ($feature->getParent() && $feature->getMandatory())
            return Logic::equiv(Logic::is($feature), Logic::is($feature->getParent()));
    }
927694
public function prune($featureTypeI18n = null)
    {
        if ($featureTypeI18n) {
            $this->addCond('pruneCond0', $this->getAliasedColName(FeatureTypeI18nTableMap::ID), $featureTypeI18n->getId(), Criteria::NOT_EQUAL);
            $this->addCond('pruneCond1', $this->getAliasedColName(FeatureTypeI18nTableMap::LOCALE), $featureTypeI18n->getLocale(), Criteria::NOT_EQUAL);
            $this->combine(array('pruneCond0', 'pruneCond1'), Criteria::LOGICAL_OR);
        }

        return $this;
    }
664203
public function isFeatureMatch(FeatureNode $feature)
    {
        return $this->filterMinLine <= $feature->getLine()
            && $this->filterMaxLine >= $feature->getLine();
    }
500644
public static <S> Feature<S,Boolean> not(Feature<? super S, Boolean> feature) {
        return FeatureExpressions.not(feature);
    }
649665
public static function findByName($features, $featureName, $permissive = false) {
        if ($permissive)
            $featureName = self::_getPermissiveName($featureName);
        return fphp\Helper\_Array::findByKey($features, $permissive ? "getPermissiveName" : "getName", $featureName);
    }
1366062
public function addFeature(FeatureInterface $feature)
    {
        $this->features->set($feature->getKey(), $feature);

        return $this;
    }
526131
function(feature) {
        var layer = feature.layer;
        if(this.hover) {
            if(this.highlightOnly) {
                this.highlight(feature);
            } else if(OpenLayers.Util.indexOf(
                layer.selectedFeatures, feature) == -1) {
                this.select(feature);
            }
        }
    }
1170708
protected function processFeature(Node\Feature $feature)
    {
        $currentFeature = [
            'uri' => $feature->getUri(),
            'id' => $feature->getId(),
            'tags' => $feature->getTags() ? $this->processTags($feature->getTags()) : [],
            'keyword' => $feature->getKeyword(),
            'name' => $feature->getName(),
            'line' => $feature->getLine(),
            'description' => $feature->getDescription(),
            'elements' => [],
        ];

        if (is_array($feature->getScenarios())) {
            foreach ($feature->getScenarios() as $scenario) {
                array_push($currentFeature['elements'], $this->processScenario($scenario));
            }
        }

        return $currentFeature;
    }
1128074
public boolean isEnabled(Feature feature) {
        Boolean enabled = features.get(feature);
        if (enabled == null) {
            return feature.isEnabledByDefault();
        } else {
            return enabled;
        }
    }
88113
public JacksonDBCollection<T, K> enable(Feature feature) {
        features.put(feature, true);
        return this;
    }
607359
public function addFeature(ScriptFeature $feature)
    {
        if (!in_array($feature, $this->features, true)) {
            array_push($this->features, $feature);
        }
        return $this;
    }
1297447
function(feature) {
        var cont = this.onBeforeSelect.call(this.scope, feature);
        var layer = feature.layer;
        if(cont !== false) {
            cont = layer.events.triggerEvent("beforefeatureselected", {
                feature: feature
            });
            if(cont !== false) {
                layer.selectedFeatures.push(feature);
                this.highlight(feature);
                // if the feature handler isn't involved in the feature
                // selection (because the box handler is used or the
                // feature is selected programatically) we fake the
                // feature handler to allow unselecting on click
                if(!this.handlers.feature.lastFeature) {
                    this.handlers.feature.lastFeature = layer.selectedFeatures[0];
                }
                layer.events.triggerEvent("featureselected", {feature: feature});
                this.onSelect.call(this.scope, feature);
            }
        }
    }
127457
public boolean selectFeature(Feature feature) {
		if (!selectedFeatures.containsKey(feature.getId())) {
			// make sure we get the layer's instance (if we can find it) !
			Feature layerFeature = getFeatureStore().getPartialFeature(feature.getId());
			if (null != layerFeature) {
				selectedFeatures.put(layerFeature.getId(), layerFeature);
				handlerManager.fireEvent(new FeatureSelectedEvent(layerFeature));
			} else {
				selectedFeatures.put(feature.getId(), feature);
				handlerManager.fireEvent(new FeatureSelectedEvent(feature));
			}
			return true;
		} else {
			return false;
		}
	}
721732
function(feature) {

        var interactive = joint.util.isFunction(this.options.interactive)
            ? this.options.interactive(this)
            : this.options.interactive;

        return (joint.util.isObject(interactive) && interactive[feature] !== false) ||
                (joint.util.isBoolean(interactive) && interactive !== false);
    }
661170
public function enabled($feature)
    {
        $feature_value = $this->value($feature);

        if (is_null($feature_value)) {
            return false;
        }

        // If value is one of the positive words configured then the
        // feature is enabled.
        if (in_array(strtoupper($feature_value), config('laraplans.positive_words'))) {
            return true;
        }

        return false;
    }
844782
protected function parse(array $features)
    {
        $allowed = [];

        foreach ($features as $feature => $value) {
            if (is_int($feature)) {
                // Allow theme features without options.
                // Though post formats must be added with properties.
                // Here we first check that "post-formats" is not provided
                // without a value. If so, just pass it.
                if (! in_array($value, $this->mustHaveProperties, true)) {
                    $allowed[$value] = $value;
                } else {
                    throw new \InvalidArgumentException(
                        'The theme feature ['.$value.'] must have a defined property in order to work.'
                    );
                }
            } else {
                $allowed[$feature] = $value;
            }
        }

        return $allowed;
    }
490308
def feature?(feature)
      supported = (definition[:features] && definition[:features].include?(feature))
      if supported
        Puppet.debug("#{definition[:name]} supports `#{feature}`")
      else
        Puppet.debug("#{definition[:name]} does not support `#{feature}`")
      end
      supported
    end