Adds a set of descriptor properties.
199035
public void putProperties(DescriptorProperties otherProperties) {
		for (Map.Entry<String, String> otherProperty : otherProperties.properties.entrySet()) {
			put(otherProperty.getKey(), otherProperty.getValue());
		}
	}
988758
private void addTenantOptions(TenantDefinition tenantDef) {
        if (tenantDef.getOption("namespace") == null) {
            tenantDef.setOption("namespace", tenantDef.getName());
        }
    }
435880
public static void addPropertiesToSpec(ModuleSpec.Builder moduleSpecBuilder, Map<String, String> properties) {
        for (Entry<String, String> entry : properties.entrySet()) {
            moduleSpecBuilder.addProperty(entry.getKey(), entry.getValue());
        }
    }
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);
    }
339700
def add (self, ps):
        
        assert isinstance(ps, PropertySet)
        if ps not in self.added_:
            self.added_[ps] = create(self.all_ + ps.all())
        return self.added_[ps]
50061
public VarValueDef addProperties( Collection<String> properties)
    {
    if( properties != null)
      {
      assertPropertyIdentifiers( properties);
      properties_.addAll( properties);
      }

    return this;
    }
175117
function addFeatures() {
        const features = {};
        for (const spec in filters.specs) {
            features[parseResults.specs.specTable[spec].feature] = true;
        }
        filters.features = features;
    }
149900
def set_properties(self, properties):
        """"""
        if isinstance(properties, dict):
            self.properties = properties
            self.sync_properties()
        else:
            self.text = properties
358519
def AddDescriptor(cls, field_desc):
    """"""
    if not isinstance(field_desc, ProtoType):
      raise type_info.TypeValueError(
          "%s field '%s' should be of type ProtoType" %
          (cls.__name__, field_desc.name))

    # Ensure the field descriptor knows the class that owns it.
    field_desc.SetOwner(cls)

    # If the field is late bound we do not really add it to the descriptor set
    # yet. We must wait for the LateBindingPlaceHolder() to add it later.
    if field_desc.late_bound:
      # Keep track of unbound fields.
      cls.late_bound_type_infos[field_desc.name] = field_desc
      return

    # Ensure this field number is unique:
    if field_desc.field_number in cls.type_infos_by_field_number:
      raise type_info.TypeValueError(
          "Field number %s for field %s is not unique in %s" %
          (field_desc.field_number, field_desc.name, cls.__name__))

    # We store an index of the type info by tag values to speed up parsing.
    cls.type_infos_by_field_number[field_desc.field_number] = field_desc
    cls.type_infos_by_encoded_tag[field_desc.encoded_tag] = field_desc

    cls.type_infos.Append(field_desc)
    cls.late_bound_type_infos.pop(field_desc.name, None)

    # Add direct accessors only if the class does not already have them.
    if not hasattr(cls, field_desc.name):
      # This lambda is a class method so pylint: disable=protected-access
      # This is much faster than __setattr__/__getattr__
      setattr(
          cls, field_desc.name,
          property(lambda self: self.Get(field_desc.name), lambda self, x: self.
                   _Set(x, field_desc), None, field_desc.description))
1008693
def add_features(self, **features):
        
        for fname, fvalue in six.iteritems(features):
            setattr(self, fname, fvalue)
            self.features.add(fname)
15502
void addGlobalUniqueProperties(Set<PropertyColumn> properties) {
        for (PropertyColumn property : properties) {
            property.addToGlobalUniqueIndexes(this);
        }
        this.properties = properties;
    }
1342284
public void addAndOverwriteProperties(Map<String, String> additionalProperties) {
        additionalProperties.values().removeAll(Collections.singleton(null));
        for (Map.Entry<String, String> additionalPropertiesMap : additionalProperties.entrySet()) {
            if (!additionalPropertiesMap.getValue().trim().isEmpty()) {
                properties.setProperty(additionalPropertiesMap.getKey(), additionalPropertiesMap.getValue());
                warnUserOfPossibleErrors(additionalPropertiesMap.getKey(), properties);
            }
        }
    }
970779
def _set_axis_properties(self, axis):
        """"""
        if not getattr(axis, 'properties'):
            axis.properties = AxisProperties()
            for prop in ['ticks', 'axis', 'major_ticks', 'minor_ticks',
                         'title', 'labels']:
                setattr(axis.properties, prop, PropertySet())
1126391
public PropertySet addAll( Iterator<String> properties)
    {
    if( properties != null)
      {
      while( properties.hasNext())
        {
        add( properties.next());
        }
      }

    return this;
    }
649228
public void setDescriptor(String descriptor)
  {
    _descriptor = descriptor;

    if (_isWrite)
      _jClass.getConstantPool().addUTF8(descriptor);
  }
716461
function addDescriptorToStatic(target, key, descriptor, inherit) {

		if (inherit == null) {
			inherit = true;
		}

		if (inherit) {
			addToStaticChain(target, key, descriptor);
		}

		Object.defineProperty(target, key, descriptor);
	}
208416
public PropertySet addAll( Collection<String> properties)
    {
    if( properties != null)
      {
      addAll( properties.iterator());
      }

    return this;
    }