set extcommunity rt additive
 set extcommunity rt 11:22 12.22.22.22:12 123.256:543
 set extcommunity rt 11:22 12.22.22.22:12 123.256:543 additive
483371
def set_extcommunity_rt_set(asn, add)
      str = ''
      # reset first
      set_args_keys(state: 'no', string: str)
      config_set('route_map', 'set_extcommunity_rt', @set_args)
      return unless add || !asn.empty?
      asn.each do |elem|
        str.concat(elem + ' ')
      end
      str.concat('additive') if add
      set_args_keys(state: '', string: str)
      config_set('route_map', 'set_extcommunity_rt', @set_args)
    end
985403
private static void setAttributes(FunctionLib extFL, FunctionLib newFL) {
	newFL.setDescription(extFL.getDescription());
	newFL.setDisplayName(extFL.getDisplayName());
	newFL.setShortName(extFL.getShortName());
	newFL.setUri(extFL.getUri());
	newFL.setVersion(extFL.getVersion());
    }
1235639
def update_exc(base_exceptions, *addition_dicts):
    
    exc = dict(base_exceptions)
    for additions in addition_dicts:
        for orth, token_attrs in additions.items():
            if not all(isinstance(attr[ORTH], unicode_) for attr in token_attrs):
                raise ValueError(Errors.E055.format(key=orth, orths=token_attrs))
            described_orth = "".join(attr[ORTH] for attr in token_attrs)
            if orth != described_orth:
                raise ValueError(Errors.E056.format(key=orth, orths=described_orth))
        exc.update(additions)
    exc = expand_exc(exc, "'", "’")
    return exc
824174
function atext() {
        return wrap('atext', compareToken(function atextFunc(tok) {
            var accept =
                ('a' <= tok && tok <= 'z') ||
                ('A' <= tok && tok <= 'Z') ||
                ('0' <= tok && tok <= '9') ||
                (['!', '#', '$', '%', '&', '\'', '*', '+', '-', '/',
                  '=', '?', '^', '_', '`', '{', '|', '}', '~'].indexOf(tok) >= 0);
            if (opts.rfc6532) {
                accept = accept || isUTF8NonAscii(tok);
            }
            return accept;
        }));
    }
1287376
def _set_prefixes(self, conf):
        
        if conf.get('legacy_namespace', 'y') in self.TRUE_VALUES:
            self.count_prefix = 'stats_counts'
            self.count_suffix = ''
            self.gauge_prefix = 'stats.gauges'
            self.timer_prefix = 'stats.timers'
            self.rate_prefix = 'stats'
            self.rate_suffix = ''
        else:
            global_prefix = conf.get('global_prefix', 'stats')
            self.count_prefix = '%s.%s' % (global_prefix,
                                           conf.get('prefix_counter',
                                                    'counters'))
            self.count_suffix = '.count'
            self.gauge_prefix = '%s.%s' % (global_prefix,
                                           conf.get('prefix_gauge', 'gauges'))
            self.timer_prefix = '%s.%s' % (global_prefix,
                                           conf.get('prefix_timer', 'timers'))
            self.rate_prefix = self.count_prefix
            self.rate_suffix = '.rate'
1071639
def _get_extra(self, attrs, exclude):
        """"""
        result = {}
        for key in attrs.getNames():
            if key not in exclude:
                result[str(key)] = str(attrs[key])
        return result
77638
protected function setExtendData()
    {
        //Check extend result methods
        if (empty($this->arExtendResult)) {
            return;
        }

        //Apply extend methods
        foreach ($this->arExtendResult as $sMethodName) {
            if (empty($sMethodName) || !(method_exists($this, $sMethodName) || $this->methodExists($sMethodName))) {
                continue;
            }

            $this->$sMethodName();
        }
    }
828878
def update(call_time, exclusive_time = nil)
      self.call_count += 1
      self.total_call_time += call_time
      self.total_exclusive_time += exclusive_time

      t = @scoped ? exclusive_time : call_time
      self.min_call_time = t if call_count == 0 || t < min_call_time
      self.max_call_time = t if t > max_call_time
    end
592592
def setAttributeType(self, namespaceURI, localName):
        '''

        '''
        self.logger.debug('setAttributeType: (%s,%s)', namespaceURI, localName)
        value = localName
        if namespaceURI:
            value = '%s:%s' %(self.getPrefix(namespaceURI),localName)

        xsi_prefix = self.getPrefix(self._xsi_nsuri)
        self._setAttributeNS(self._xsi_nsuri, '%s:type' %xsi_prefix, value)
1270894
def update_to_v24(self):
        

        self.__update_common()

        # TDAT, TYER, and TIME have been turned into TDRC.
        try:
            date = text_type(self.get("TYER", ""))
            if date.strip(u"\x00"):
                self.pop("TYER")
                dat = text_type(self.get("TDAT", ""))
                if dat.strip("\x00"):
                    self.pop("TDAT")
                    date = "%s-%s-%s" % (date, dat[2:], dat[:2])
                    time = text_type(self.get("TIME", ""))
                    if time.strip("\x00"):
                        self.pop("TIME")
                        date += "T%s:%s:00" % (time[:2], time[2:])
                if "TDRC" not in self:
                    self.add(TDRC(encoding=0, text=date))
        except UnicodeDecodeError:
            # Old ID3 tags have *lots* of Unicode problems, so if TYER
            # is bad, just chuck the frames.
            pass

        # TORY can be the first part of a TDOR.
        if "TORY" in self:
            f = self.pop("TORY")
            if "TDOR" not in self:
                try:
                    self.add(TDOR(encoding=0, text=str(f)))
                except UnicodeDecodeError:
                    pass

        # IPLS is now TIPL.
        if "IPLS" in self:
            f = self.pop("IPLS")
            if "TIPL" not in self:
                self.add(TIPL(encoding=f.encoding, people=f.people))

        # These can't be trivially translated to any ID3v2.4 tags, or
        # should have been removed already.
        for key in ["RVAD", "EQUA", "TRDA", "TSIZ", "TDAT", "TIME"]:
            if key in self:
                del(self[key])

        # Recurse into chapters
        for f in self.getall("CHAP"):
            f.sub_frames.update_to_v24()
        for f in self.getall("CTOC"):
            f.sub_frames.update_to_v24()
333326
def taint(taintedSet, taintedAttribute):
    """
    taintedSet.add(taintedAttribute)
    if taintedAttribute == 'marker':
        taintedSet |= set(['marker-start', 'marker-mid', 'marker-end'])
    if taintedAttribute in ['marker-start', 'marker-mid', 'marker-end']:
        taintedSet.add('marker')
    return taintedSet
755165
def setxattr(self, req, ino, name, value, flags):
        
        self.reply_err(req, errno.ENOSYS)
1352073
function addXSetMember (key, timestamp, field, value, res, next) {
  let redisConnection = res.locals.connection;
  myutil.decodeHTMLEntities(field, function (decodedField) {
    myutil.decodeHTMLEntities(value, function (decodedValue) {
      redisConnection.xadd(key, timestamp, decodedField, decodedValue, function (err) {
        if (err) {
          console.error('addXSetMember', err);
          return next(err);
        }
        return res.send('ok');
      });
    });
  });
}
150005
function applyTTL (cond) {
    if (cond[key]) {
      cond.$and || (cond.$and = []);
      var a = {};
      a[key] = cond[key];
      cond.$and.push(a);
      var b = {};
      b[key] = { $gt: new Date };
      cond.$and.push(b);
      delete cond[key];
    } else {
      cond[key] = { $gt: new Date };
    }
  }
917102
def set(self, path, value, version=-1):
        
        value = to_bytes(value)
        super(XClient, self).set(path, value, version)
803536
protected void setPrepareXAFailed() // d266464A
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "setPrepareXAFailed");

        setRBO(); // Ensure native context is informed

        if (tc.isEntryEnabled())
            Tr.exit(tc, "setPrepareXAFailed");
    }
1133611
def add_exp_key(self, key, value, ex):
        ""
        return self.c.set(key, value, ex)