Add tags for Swig
328957
function setTags(swig, tags) {
  var name, tag;
  for (name in tags) {
    tag = tags[name];
    swig.setTag(name, tag.parse, tag.compile, tag.ends, tag.blockLevel);
  }
}
531430
def append_tag(self, field_number, wire_type):
        """"""
        self._stream.append_var_uint32(wire_format.pack_tag(field_number, wire_type))
420752
def add_tag(self, new_tags):
        

        tags = self.get_tags()
        orig_tag_cnt = len(tags)
        # print("self.get_tags() {}".format(tags))

        if isinstance(new_tags, six.string_types):
            new_tags = new_tags.split(',')
            # print("spliting tags :: {}".format(new_tags))

        for tag in new_tags:
            if not tag in tags:
                tags.append(tag.strip())

        if len(tags) > orig_tag_cnt:
            xml_tags = escape(",".join(tags))
            post_data = TAGS_TEMPLATE.format(connectware_id=self.get_connectware_id(),
                                             tags=xml_tags)
            self._conn.put('/ws/DeviceCore', post_data)

            # Invalidate cache
            self._device_json = None
178733
def add_tag(self, resource_type, resource_id, tag, **_params):
        """"""
        return self.put(self.tag_path % (resource_type, resource_id, tag))
1009966
def AddClusterTags(r, tags, dry_run=False):
    

    query = {
        "dry-run": dry_run,
        "tag": tags,
    }

    return r.request("put", "/2/tags", query=query)
762676
function View_setTag(name, parse, compile, ends, blockLevel) {
            this.swig.setTag(name, parse, compile, ends, blockLevel);
        }
716412
def tag(self, *tag, **kwtags):
        """"""
        if not tag:
            pass
        elif len(tag) == 1 and isinstance(tag[0], dict):
            self._meta.update(tag[0])
        else:
            raise TypeError('Tags must be provided as key-word arguments or '
                            'a dictionary')
        self._meta.update(kwtags)
        return self
369574
public void addTag(IccTag tag) {
    tags.add(tag);
    hashTagsId.put(tag.signature, tag);
    Tag t = TiffTags.getTag(tag.signature);
    if (t != null)
      hashTagsName.put(t.getName(), tag);
  }
1364217
function add_tags( $tags )
	{
		$params = array();
		if (is_array($tags) && !empty($tags)) {
			$params['tags'] = join(',', $tags);
		} else {
			$params['tags'] = $tags;
		}
		return $this->oauth->post( 'tags/create', $params);
	}
354136
def database_add_tags(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/addTags' % object_id, input_params, always_retry=always_retry, **kwargs)
856196
private function add_strip_tags() {
		$this->engine->addHelper(
			'strip_tags',
			function ( $template, $context, $args ) {
					$arg = $context->get( $args );
					return strip_tags( $arg );
			}
		);
	}
304813
def add_tag(self, task, params={}, **options): 
        
        path = "/tasks/%s/addTag" % (task)
        return self.client.post(path, params, **options)
589437
def add_tags(jobflow_id, tags)
      params = {
        :operation => 'AddTags',
        :resource_id => jobflow_id,
        :tags => tags
      }
      aws_result = @aws_request.submit(params)
      yield aws_result if block_given?
    end
280400
def add_tags(self, archive_name, tags):
        '''
        

        '''
        updated_tag_list = list(self._get_tags(archive_name))
        for tag in tags:
            if tag not in updated_tag_list:
                updated_tag_list.append(tag)

        self._set_tags(archive_name, updated_tag_list)
1240843
def _add_tag(self, tag):
        # type: (str) -> bool
        
        tags = self.data.get('tags', None)
        if tags:
            if tag in [x['name'] for x in tags]:
                return False
        else:
            tags = list()
        tags.append({'name': tag})
        self.data['tags'] = tags
        return True
125888
function tag (msg, done) {
    var clean_data = {
      source: 'demo-plugin',
      payload: msg.payload
    }

    done(null, clean_data)
  }
709203
function processNpmLine(line) {
    if (swig.argv.useYarn) {
      try {
        processYarnLine(line);
      } catch (e) {
        // NOTE: Some output lines come joined together. Splitting them here
        // and processing them one by one.
        if (/\n/.test(line)) {
          const lines = line.split(/\n/);
          lines.forEach((_line) => {
            processYarnLine(_line);
          });
        }
      }
      return;
    }

    line = swig.log.strip(line).trim();

    swig.log.verbose(line);

    let moduleName;

    if (regex.requested.test(line)) {
      moduleName = line.replace(regex.requested, '$1');

      swig.log.verbose(`${swig.log.padding + swig.log.padding + '→'.white}  ${moduleName}`);
    } else if (regex.installed.test(line)) {
      moduleName = line.replace(regex.installed, '$3 v$4');

      if (!_.contains(downloaded, moduleName)) {
        downloaded.push(moduleName);

        swig.log(`${swig.log.strip(swig.log.symbols.download).green}  ${moduleName}`);
      }
    } else if (regex.fourohfour.test(line)) {
      swig.log();
      swig.log.error('install', `Module not found: ${line.replace(regex.fourohfour, '$1')}`);
    } else if (regex.noversion.test(line)) {
      swig.log();
      swig.log.error('install', line.replace(regex.noversion, '$1'));
      swig.log('\nTry specifying a different version. use `npm view <module>` to display available versions for a module.\n');
    } else if (regex.error.test(line)) {
      swig.log();
      swig.log.error('install', line.replace(regex.error, '$1'));
    }
  }