Add likely subtags, producing the max bundle ID.
496423
protected MetaLocale addLikelySubtags(MetaLocale src) {
    // Always return a copy.
    MetaLocale dst = src.copy();

    // If the locale has all fields populated (language, script, territory)
    // then do nothing.
    if (src.hasAll()) {
      return dst;
    }

    // Build a temporary locale for matching and clear the variant since it
    // is not used for likely subtags.
    MetaLocale temp = src.copy();
    temp.setVariant(null);

    // Iterate over the match flags, from most specific to least.
    for (int flags : MATCH_ORDER) {
      set(src, temp, flags);
      MetaLocale match = likelySubtagsMap.get(temp);
      if (match != null) {
        // Use the first match we find. We only replace subtags that
        // are undefined, copying them from the matched locale.
        if (!dst.hasLanguage()) {
          dst.setLanguage(match._language());
        }
        if (!dst.hasScript()) {
          dst.setScript(match._script());
        }
        if (!dst.hasTerritory()) {
          dst.setTerritory(match._territory());
        }
        break;
      }
    }

    return dst;
  }
927397
def add_tag(self, tag):
        
        if tag not in self._tags:
            self._tags[tag] = dict()
490323
def add_size_info (self):
        """"""
        maxbytes = self.aggregate.config["maxfilesizedownload"]
        if self.size > maxbytes:
            self.add_warning(
              _("Content size %(size)s is larger than %(maxbytes)s.") %
                  dict(size=strformat.strsize(self.size),
                       maxbytes=strformat.strsize(maxbytes)),
                tag=WARN_URL_CONTENT_SIZE_TOO_LARGE)
328331
private void tagSubtypesAsAffectedByReload() {
		if (associatedSubtypes != null) {
			for (Reference<ReloadableType> ref : associatedSubtypes) {
				ReloadableType rsubtype = ref.get();
				if (rsubtype != null) {
					rsubtype.tagAsAffectedByReload();
					rsubtype.tagSubtypesAsAffectedByReload();
				}
			}
		}
	}
1302116
def _addTags(tags, objects):
    
    for t in tags:
        for o in objects:
            o.tags.add(t)

    return True
1046778
function addAssociatedDomains(preferences) {
    const files = getEntitlementFiles(preferences);

    for (let i = 0; i < files.length; i++) {
      const file = files[i];
      let entitlements = getEntitlements(file);

      entitlements = updateEntitlements(entitlements, preferences);
      setEntitlements(file, entitlements);
    }
  }
62334
def add_tags(self, *tags):
        
        self.tags.extend([
            Tag(name=tag) for tag in tags
        ])
995703
def add(self, campaign_id, item_id, default_price, title, img_url, nick=None):
        ''''''
        request = TOPRequest('xxxxx.xxxxx.adgroup.add')
        request['campaign_id'] = campaign_id
        request['item_id'] = item_id
        request['default_price'] = default_price
        request['title'] = title
        request['img_url'] = img_url
        if nick!=None: request['nick'] = nick
        self.create(self.execute(request), fields=['success','result','success','result_code','result_message'], models={'result':ADGroup})
        return self.result
290350
def tag_add(self, item, tag):
        
        tags = self.item(item, "tags")
        self.item(item, tags=tags + (tag,))
709673
def add_chain_info(data_api, data_setters, chain_index):
    """"""
    chain_id = data_api.chain_id_list[chain_index]
    chain_name = data_api.chain_name_list[chain_index]
    num_groups = data_api.groups_per_chain[chain_index]
    data_setters.set_chain_info(chain_id, chain_name, num_groups)
    next_ind = data_api.group_counter + num_groups
    last_ind = data_api.group_counter
    for group_ind in range(last_ind, next_ind):
        add_group(data_api, data_setters, group_ind)
        data_api.group_counter +=1
    data_api.chain_counter+=1
1005983
def add_quantity(self,
                     quantities,
                     value,
                     source,
                     check_for_dupes=True,
                     compare_to_existing=True,
                     **kwargs):
        """"""
        success = True
        for quantity in listify(quantities):
            kwargs.update({QUANTITY.VALUE: value, QUANTITY.SOURCE: source})
            cat_dict = self._add_cat_dict(
                Quantity,
                quantity,
                compare_to_existing=compare_to_existing,
                check_for_dupes=check_for_dupes,
                **kwargs)
            if isinstance(cat_dict, CatDict):
                self._append_additional_tags(quantity, source, cat_dict)
                success = False

        return success
1368921
public function addTags(): void
    {
        $tags = $this->getTags();
        $currentStructureUuid = $this->getCurrentStructureUuid();
        if ($currentStructureUuid && !in_array($currentStructureUuid, $tags)) {
            $tags[] = $currentStructureUuid;
        }

        if (count($tags) <= 0) {
            return;
        }

        $this->symfonyResponseTagger->addTags($tags);
    }
1086579
def onTagAdd(self, name, func):
        '''
        

        '''
        # TODO allow name wild cards
        if '*' in name:
            self.ontagaddglobs.add(name, func)
        else:
            self.ontagadds[name].append(func)
305777
def add_sequence(tag, options={})
      add(s = Sequence.new(tag, options))
      s
    end
56017
def addidsuffix(self, idsuffix, recursive = True):
        """"""
        if self.id: self.id += idsuffix
        if recursive:
            for e in self:
                try:
                    e.addidsuffix(idsuffix, recursive)
                except Exception:
                    pass
149975
def add_tags(ctx, archive_name, tags):
    '''
    
    '''

    _generate_api(ctx)

    var = ctx.obj.api.get_archive(archive_name)

    var.add_tags(*tags)
1242896
def _add_tag_files(
    zip_file, dir_name, payload_info_list, payload_byte_count, payload_file_count
):
    """"""
    tag_info_list = []
    _add_tag_file(zip_file, dir_name, tag_info_list, _gen_bagit_text_file_tup())
    _add_tag_file(
        zip_file,
        dir_name,
        tag_info_list,
        _gen_bag_info_file_tup(payload_byte_count, payload_file_count),
    )
    _add_tag_file(
        zip_file, dir_name, tag_info_list, _gen_pid_mapping_file_tup(payload_info_list)
    )
    return tag_info_list