Public: Sets the model tags
 `names` must be a list of tag names, separated by commas
431793
def tag_list=(names)
      self.tags = names.split(",").map do |n|
        SimpleTags::Tag.where(name: n.strip).first_or_create!
      end
    end
1236847
public void setTags(java.util.Collection<java.util.Map<String, String>> tags) {
        if (tags == null) {
            this.tags = null;
            return;
        }

        this.tags = new java.util.ArrayList<java.util.Map<String, String>>(tags);
    }
1112297
def normalizeToName(val):
    
    if val not in tagsAndNameSet:
        raise KeyError("{} is not a tag or name string".format(val))
    else:
        try:
            return tagToFullDict[val]
        except KeyError:
            return val
837209
def []=(name, value)
      raise Error, "cannot set value for a Model" if @elements[name].is_a? Model
      @elements[name].value = value
    end
704877
def set_name_with_model(self, model):
        
        table_name = model._meta.db_table
        column_names = [model._meta.get_field(field_name).column for field_name, order in self.fields_orders]
        column_names_with_order = [
            (('-%s' if order else '%s') % column_name)
            for column_name, (field_name, order) in zip(column_names, self.fields_orders)
        ]
        # The length of the parts of the name is based on the default max
        # length of 30 characters.
        hash_data = [table_name] + column_names_with_order + [self.suffix] + self.name_hash_extra_data()
        self.name = '%s_%s_%s' % (
            table_name[:11],
            column_names[0][:7],
            '%s_%s' % (self._hash_generator(*hash_data), self.suffix),
        )
        assert len(self.name) <= self.max_name_length, (
            'Index too long for multiple database support. Is self.suffix '
            'longer than 3 characters?'
        )
        self.check_name()
304639
def tag(self, *tags):
        
        if any([not isinstance(tag, collections.Hashable) for tag in tags]):
            raise TypeError('Every tag should be hashable')

        if not all(isinstance(tag, collections.Hashable) for tag in tags):
            raise TypeError('Tags must be hashable')
        self.tags.update(tags)
        return self
1318611
protected function setIgnoreTags()
    {
        if (!count($this->ignore_tags)) {
            $this->ignore_tags = array_keys($this->parser->tags->all());
        }
    }
961866
public Input withTags(java.util.Map<String, String> tags) {
        setTags(tags);
        return this;
    }
773114
def _taglist(self, other_model=None, queryset=None):
        
        from taggit.models import TaggedItem
        filter = None
        if queryset is not None:
            filter = set()
            for item in queryset.all():
                filter.update(item.tags.all())
            filter = set([tag.id for tag in filter])
        elif other_model is not None:
            filter = set(TaggedItem.objects.filter(
                content_type__model=other_model.__name__.lower()
            ).values_list('tag_id', flat=True))
        tags = set(TaggedItem.objects.filter(
            content_type__model=self.model.__name__.lower()
        ).values_list('tag_id', flat=True))
        if filter is not None:
            tags = tags.intersection(filter)
        return list(tags)
480800
def prepare_bundles_set_params(name_or_bundle, tags = [])
        bundle = prepare_param_bundle(name_or_bundle, tags) do |b|
          raise Error, "Bundle name is empty" if b.name.empty?
          raise Error, "Bundle must contain at least one tag" if b.tags.empty?
        end
        { :bundle => bundle.name, :tags => bundle.tags.join(' ') }
      end
1234544
public R setTags(List<String> tags) {
        JsonArray jsonArray = new JsonArray();
        for (String s : tags) {
            jsonArray.add(s);
        }
        mBodyMap.put(BoxItem.FIELD_TAGS, jsonArray);
        return (R) this;
    }
51068
public void setTags(String tags) {
                if (GitTaskUtils.isNullOrBlankString(tags)) {
                        throw new BuildException("Invalid tag names provided.");
                }

                this.tags = tags.split(",");
        }
277214
public void setTagValues(String name, String values[]) {
        removeTag(name);
        XtraTag tag = new XtraTag(name);
        for (int i = 0; i < values.length; i++) {
            tag.values.addElement(new XtraValue(values[i]));
        }
        tags.addElement(tag);
    }
449331
public void setNames(java.util.Collection<String> names) {
        if (names == null) {
            this.names = null;
            return;
        }

        this.names = new java.util.ArrayList<String>(names);
    }
993522
def tags(self, val: str) -> None:
        

        if not StorageRecord.ok_tags(val):
            LOGGER.debug('StorageRecord.__init__ <!< Tags %s must map strings to strings', val)
            raise BadRecord('Tags {} must map strings to strings'.format(val))

        self._tags = val or {}
964138
def tags(self, value):
        
        if value == self._defaults['tags'] and 'tags' in self._values:
            del self._values['tags']
        else:
            self._values['tags'] = value
236255
protected void setNames(Set<String> names)
   {
      this.names.clear();
      this.indexes.clear();
      this.names.addAll(names);
      this.indexes.addAll(names);
      // new list of indexes if thought to be up to date
      dirty = false;
   }