Adds the given values to the given feature.
549261
def extend (name, values):
    
    assert isinstance(name, basestring)
    assert is_iterable_typed(values, basestring)
    name = add_grist (name)
    __validate_feature (name)
    feature = __all_features [name]

    if feature.implicit:
        for v in values:
            if v in __implicit_features:
                raise BaseException ("'%s' is already associated with the feature '%s'" % (v, __implicit_features [v]))

            __implicit_features[v] = feature

    if values and not feature.values and not(feature.free or feature.optional):
        # This is the first value specified for this feature,
        # take it as default value
        feature.set_default(values[0])

    feature.add_values(values)
1081076
def change (properties, feature, value = None):
    
    assert is_iterable_typed(properties, basestring)
    assert isinstance(feature, basestring)
    assert isinstance(value, (basestring, type(None)))
    result = []

    feature = add_grist (feature)

    for p in properties:
        if get_grist (p) == feature:
            if value:
                result.append (replace_grist (value, feature))

        else:
            result.append (p)

    return result
1148127
function(feature, node) {
        for (var key in feature.attributes) {
            var tag = this.createElementNS(null, "tag");
            tag.setAttribute("k", key);
            tag.setAttribute("v", feature.attributes[key]);
            node.appendChild(tag);
        }
    }
1158956
public function addValue(\Dywee\ProductBundle\Entity\FeatureValue $values)
    {
        $this->values[] = $values;

        return $this;
    }
675315
@SuppressWarnings("unchecked")
    public T addAll(YamlNode... values) {
        for (YamlNode value : values) {
            add(value);
        }
        return (T) this;
    }
1353832
public void add(ShortArrayList values) {
        ensureCapacity(size + values.size);
        for (int i=0; i<values.size; i++) {
            this.add(values.elements[i]);
        }
    }
181221
def addFeatureSet(self, featureSet):
        
        id_ = featureSet.getId()
        self._featureSetIdMap[id_] = featureSet
        self._featureSetIds.append(id_)
        name = featureSet.getLocalId()
        self._featureSetNameMap[name] = featureSet
187165
public void add( T value ) {
        Lock lock = this.lock.writeLock();
        try {
            lock.lock();
            doAddValue(value);
        } finally {
            lock.unlock();
        }
    }
476855
public VarDefBuilder values( VarValueDef... values)
    {
    for( VarValueDef value : values)
      {
      varDef_.addValue( value);
      }
    return this;
    }
544633
public void addValues(String name, List<V> values) {
        List<V> lo = get(name);
        if (lo == null) {
            lo = new ArrayList<>();
        }
        lo.addAll(values);
        put(name, lo);
    }
1062164
public void addFeatures(List<Feature> features) {
		numFeatures += features.size();
		for (Feature feature : features) {
			featureListGrid.addFeature(feature);
		}
		if (sortFeatures) {
			featureListGrid.sort(sortFieldName, sortDirGWT);
		}
		
		if (exportCsvHandler instanceof ExportFeatureListToCsvHandler) {
			((ExportFeatureListToCsvHandler) exportCsvHandler).setFeatures(features);
		}
	}
219315
public void add(double addend) {  
        for (int c = 0; c < this.values.length; c++) {
            addValue(c, addend);
        }
    }
443121
def add(self, value):
        """"""
        if value not in self._set:
            self._set.add(value)
            self._list.add(value)
936327
public void add(byte[] values) {
        ensureCapacity(size + values.length);
        for (byte element : values) {
            this.add(element);
        }
    }
516688
private static void addFeatures(Featurable featurable, Services services, Setup setup)
    {
        final List<Feature> rawFeatures = FeaturableConfig.getFeatures(services, setup);
        final int length = rawFeatures.size();
        for (int i = 0; i < length; i++)
        {
            final Feature feature = rawFeatures.get(i);
            featurable.addFeature(feature);
        }
        featurable.addAfter(services, setup);
    }
786000
public void incrementFeature(Assignment featureAssignment, double amount) {
    if (isDense) {
      statistics.incrementEntry(amount, statisticNames.assignmentToIntArray(featureAssignment));
    } else {
      Tensor increment = SparseTensor.singleElement(getTensorDimensions(), getTensorSizes(),
          statisticNames.assignmentToIntArray(featureAssignment), amount);
      statisticsTensor = statisticsTensor.elementwiseAddition(increment);
    }
  }
1368200
public void add(Featurable featurable)
    {
        featurables.put(featurable.getFeature(Identifiable.class).getId(), featurable);

        for (final Class<?> type : featurable.getClass().getInterfaces())
        {
            addType(type, featurable);
        }

        for (final Class<? extends Feature> feature : featurable.getFeaturesType())
        {
            final Feature object = featurable.getFeature(feature);
            addType(feature, object);
            for (final Class<?> other : UtilReflection.getInterfaces(feature, Feature.class))
            {
                addType(other, object);
            }
        }
        addType(featurable.getClass(), featurable);
        addSuperClass(featurable, featurable.getClass());
    }