Add the specified members to the Set.

        :param name: str     the name of the redis key
        :param values: a list of values or a simple value.
        :return: Future()
515901
def sadd(self, name, values, *args):
        
        with self.pipe as pipe:
            values = [self.valueparse.encode(v) for v in
                      self._parse_values(values, args)]
            return pipe.sadd(self.redis_key(name), *values)
1347840
def addmember(self, value):
        

        if value is not None and not isinstance(value, Agent):
            value = Agent(value)

        self._member.append(value)
110753
def add_result(self, values):
        
        idx = [values['host']]
        for gid in self.key_gids[1:]:
            idx.append(values[gid])
        idx = tuple(idx)

        try:
            self.results[idx] += 1
        except KeyError:
            self.results[idx] = 1
        self._last_idx = idx
590137
def add(self, name, value):
        ''''''
        normalized_name = normalize_name(name, self._normalize_overrides)
        self._map[normalized_name].append(value)
984777
def add_key_value(self, key, value):
        
        if key == 'unique_id':
            self._unique_id = str(value)
        else:
            self._data[key] = value
583270
def addCodedValue(self, name, code):
        
        i = {"name" : name, "code" : code}
        if i not in self._codedValues:
            self._codedValues.append(i)
886231
def increment(self, name, value):
        
        for counter in self._counters:
            counter.increment(name, value)
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');
      });
    });
  });
}
153401
def extend(self, other):
        
        def extend_trans(pipe):
            values = list(other.__iter__(pipe)) if use_redis else other
            for v in values:
                self._append_helper(v, pipe)

        if self._same_redis(other, RedisCollection):
            use_redis = True
            self._transaction(extend_trans, other.key)
        else:
            use_redis = False
            self._transaction(extend_trans)
671841
function add(values, value) {
  var self = this

  if (value) {
    self.map[values] = value
  } else {
    addAll(self.map, values)
  }

  return self
}
1337950
def add(self, key, val):
        
        key_lower = key.lower()
        new_vals = [key, val]
        # Keep the common case aka no item present as fast as possible
        vals = self._container.setdefault(key_lower, new_vals)
        if new_vals is not vals:
            vals.append(val)
1279421
def add(self, value, session=None, **kwargs):
        ''''''
        s, instance = self.session_instance('add', value, session, **kwargs)
        return s.add(instance)
1040298
public void setHeaderValues(String name,String[] values)
    {
        _fields.put(name,Arrays.asList(values));
    }
502340
def hgetall(self, name):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.hgetall(self.redis_key(name))

            def cb():
                data = {}
                m_decode = self.memberparse.decode
                v_decode = self._value_decode
                for k, v in res.result.items():
                    k = m_decode(k)
                    v = v_decode(k, v)
                    data[k] = v
                f.set(data)

            pipe.on_execute(cb)
            return f
456733
def add(self, value):
        """"""
        # Raise TypeError if value is not hashable
        hash(value)

        self.redis.sadd(self.key, self._pickle(value))
345571
public void add(String name, String... values) {
    if (containsKey(name)) {
      List<String> list = get(name);
      for (String value: values) {
        list.add(value);
      }
    } else {
      put(name, values);
    }
  }
199982
def extend(self, other):
        
        def extend_trans(pipe):
            values = list(other.__iter__(pipe)) if use_redis else other
            len_self = pipe.rpush(self.key, *(self._pickle(v) for v in values))
            if self.writeback:
                for i, v in enumerate(values, len_self - len(values)):
                    self.cache[i] = v

        if self._same_redis(other, RedisCollection):
            use_redis = True
            self._transaction(extend_trans, other.key)
        else:
            use_redis = False
            self._transaction(extend_trans)