Set the ancestor for the query

        :type value: :class:`~google.cloud.datastore.key.Key`
        :param value: the new ancestor key
341541
def ancestor(self, value):
        
        if not isinstance(value, Key):
            raise TypeError("Ancestor must be a Key")
        self._ancestor = value
751295
def __inner_set_default(self, key, value):
        
        path = self.__path_of(key)

        try:
            # Try to get and return the existing node with its data
            value, _ = self.connection.retry(self.connection.get, path)
            return self.encoding.decode(value)
        except self.no_node_error:
            # Node does not exist, we have to create it
            self.connection.retry(self.connection.create, path, self.encoding.encode(value))
            self.__increment_last_updated()
            return value
671126
def set(key , value)
      index = key_index(key)
      if( index )
        i_values.set(index , value)
      else
        i_keys.push(key)
        i_values.push(value)
      end
      value
    end
4721
def set(self, key, val, bucket):
        

        if bucket not in self._cache:
            self._cache[bucket] = {}

        self._cache[bucket][key] = val
1311691
def set(self, value):
        

        if isinstance(value, str_cls):
            if self._map is None:
                raise ValueError(unwrap(
                    '''
                    %s value is a unicode string, but no _map provided
                    ''',
                    type_name(self)
                ))

            if value not in self._reverse_map:
                raise ValueError(unwrap(
                    '''
                    %s value, %s, is not present in the _map
                    ''',
                    type_name(self),
                    value
                ))

            value = self._reverse_map[value]

        elif not isinstance(value, int_types):
            raise TypeError(unwrap(
                '''
                %s value must be an integer or unicode string when a name_map
                is provided, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        self._native = self._map[value] if self._map and value in self._map else value

        self.contents = int_to_bytes(value, signed=True)
        self._header = None
        if self._trailer != b'':
            self._trailer = b''
1287201
private void setConsistencylevel(Object value)
    {
        if (value instanceof String)
        {
            this.cassandraClientBase.setConsistencyLevel(ConsistencyLevel.valueOf((String) value));
        }
        else if (value instanceof ConsistencyLevel)
        {
            this.cassandraClientBase.setConsistencyLevel((ConsistencyLevel) value);
        }

    }
158847
def set(self, key: Any, value: Any) -> None:
        
        if key is not None:
            self[key] = value
1187595
def use(self, key, value):
        
        old_value = self[key]
        try:
            self[key] = value
            yield self
        finally:
            self[key] = old_value
694927
def set(self, instance, value, **kw):
        
        return self._set(instance, value, **kw)
87126
public void set(E key, T value) 
    {
        Entry<E, T> entry = new Entry<E, T>(key, value, null, null);
        
        synchronized(this) {
            if (map.get(key) == null) {
                
                if (this.length >= this.capacity) 
                    this.removeLeastUsedElements();

                entry.prev = this.head;
                entry.next = this.head.next;
                this.head.next.prev = entry;
                this.head.next = entry;
                
                this.length++;
                map.put(key, entry);
            } else {
                entry = map.get(key);
                
                entry.value = value;
                
                entry.prev.next = entry.next;
                entry.next.prev = entry.prev;
                
                entry.prev = this.head;
                entry.next = this.head.next;
                this.head.next.prev = entry;
                this.head.next = entry;
            }
        }
    }
674308
def set(self, key, value):
        
        return self.__setitem__(key, value, force=True)
236542
def set(self, key, value, key_length=0):
        
        if key_length < 1:
            key_length = len(key)
        if self.k:
            self._update(key, value)
        return self.set_method(self, key, key_length, value)
785409
function set(key, value) {
  const entry = this.get(key, true);
  let oldvalue;
  if (entry) {
    oldvalue = entry.value;
    entry.value = value;
  } else {
    oldvalue = this.put(key, value);
    if (oldvalue) oldvalue = oldvalue.value;
  }
  return oldvalue;
}
312506
public static Key ancestor(Key key) {
		Key ancestor = key;
		
		while (ancestor.getParent() != null) {
			ancestor = ancestor.getParent();
		}
		
		return ancestor;
	}
1133333
def add_default(self, key: str, value: Optional[str], default_type: type = str) -> None:
        
        self.defaults[key] = HierarkeyDefault(value, default_type)
410958
def set_value(self, treeiter, column, value):
        

        value = self._convert_value(column, value)
        Gtk.TreeStore.set_value(self, treeiter, column, value)
421803
def set(self, key, value, **kw):
        

        self.impl.set(key, value, **self._get_cache_kw(kw, None))