Sets the alias name for the interface.

 @raise [Error] Raised when a new nickname could not be set.
 @param [String] nick The alias name for the interface.
336116
def nick=(nick)
      success = Utils.call_executable_returning_status(
        '-i', id, '--nick', nick, '--update'
      )
      unless success
        raise Error, "Unable to set nickname for interface (#{id}). " \
                    'Please make sure the vnstat daemon is not running while ' \
                    'performing this operation.'
      end
      @nick = nick
    end
668567
public function setNickname($nick = null)
    {
        $deferred = new Deferred();

        $nick    = $nick ?: '';
        $payload = [
            'nick' => $nick,
        ];

        // jake plz
        if ($this->discord->id == $this->user->id) {
            $promise = $this->http->patch("guilds/{$this->guild_id}/members/@me/nick", $payload);
        } else {
            $promise = $this->http->patch("guilds/{$this->guild_id}/members/{$this->user->id}", $payload);
        }

        $promise->then(
            \React\Partial\bind_right($this->resolve, $deferred),
            \React\Partial\bind_right($this->reject, $deferred)
        );

        return $deferred->promise();
    }
541619
def add_user(self, nick, prefixes=None):
        """"""
        if nick not in self._user_nicks:
            self._user_nicks.append(nick)

        self.prefixes[nick] = prefixes
1315936
def _parse_nick(client, command, actor, args):
    
    old_nick, _, _ = actor.partition('!')
    new_nick = args

    if old_nick == client.user.nick:
        client.user.nick = new_nick

    modified_channels = set()
    for channel in client.server.channels.itervalues():
        user = channel.members.get(old_nick)
        if user:
            user.nick = new_nick
            channel.members[new_nick] = user
            del channel.members[old_nick]
            modified_channels.add(channel.name)

    client.dispatch_event("NICK", old_nick, new_nick)
    for channel in modified_channels:
        client.dispatch_event("MEMBERS", channel)
448963
def set_daemon_name(self, daemon_name):
        
        self.daemon_name = daemon_name
        for instance in self.instances:
            instance.set_loaded_into(daemon_name)
783763
def aliased_slot_name(self, slot: SLOT_OR_SLOTNAME) -> str:
        
        if isinstance(slot, str):
            slot = self.schema.slots[slot]
        return slot.alias if slot.alias else slot.name
70434
def _onAs( self, name ):
        "  "
        if self.__lastImport.what:
            self.__lastImport.what[ -1 ].alias = name
        else:
            self.__lastImport.alias = name
        return
744136
def add_alias(self, alias, indices, **kwargs):
        
        indices = self.conn._validate_indices(indices)

        return self.change_aliases(['add', index, alias,
                                    self._get_alias_params(**kwargs)]
                                    for index in indices)
1153360
def match(self, name):
		''''''
		if (self.ns + self.name).startswith(name):
			return True

		for alias in self.aliases:
			if (self.ns + alias).startswith(name):
				return True
938384
public void setAlias(String alias) {
        this.alias = (alias != null && alias.isEmpty() == false ? alias : null);
    }
1342080
def setSignalName(self, name: str):
        
        self.isHook = False
        self.messengerName = name
412558
public void setProgramName(String name, String... aliases) {
        programName = new ProgramName(name, Arrays.asList(aliases));
    }
1352438
def aliased_slot_names(self, slot_names: List[SlotDefinitionName]) -> Set[str]:
        
        return {self.aliased_slot_name(sn) for sn in slot_names}
229537
def register_alias(self, alias, key):
        
        alias = alias.lower()
        key = key.lower()
        if alias != key and alias != self._real_key(key):
            exists = self._aliases.get(alias)

            if exists is None:
                # if we alias something that exists in one of the dicts to
                # another name, we'll never be able to get that value using the
                # original name, so move the config value to the new _real_key.
                val = self._config.get(alias)
                if val:
                    self._config.pop(alias)
                    self._config[key] = val
                val = self._kvstore.get(alias)
                if val:
                    self._kvstore.pop(alias)
                    self._kvstore[key] = val
                val = self._defaults.get(alias)
                if val:
                    self._defaults.pop(alias)
                    self._defaults[key] = val
                val = self._override.get(alias)
                if val:
                    self._override.pop(alias)
                    self._override[key] = val

                self._aliases[alias] = key
        else:
            log.warning("Creating circular reference alias {0} {1} {2}".format(
                alias, key, self._real_key(key)))
1068623
def name(self, name):
        
        success = idaapi.set_enum_member_name(self.cid, name)
        if not success:
            raise exceptions.CantRenameEnumMember(
                "Failed renaming {!r} to {!r}. Does the name exist somewhere else?".format(self.name, name))
83736
def set_table_name
      [self.old_name, self.new_name].each do |name|
        # make sure this table exists
        if self.table_exists?(name)
          # return true if we are already using this table
          return true if self.klass.table_name == name.to_s
          # otherwise we can change the table name
          self.klass.table_name = name
          return true
        end
      end
      self.raise_no_table_error
    end
1249609
def set_aliases(self, new_value):
        ""
        try:
            self.aliases = new_value
        except Exception as err:
            raise ValueError("invalid value: {}".format(err))