Creates an alias.
352652
final public function alias(string $id, string $referencedId): AliasConfigurator
    {
        $this->__destruct();

        return $this->parent->alias($id, $referencedId);
    }
982736
protected void addAlias(MonolingualTextValue alias) {
        String lang = alias.getLanguageCode();
        AliasesWithUpdate currentAliasesUpdate = newAliases.get(lang);
        
        NameWithUpdate currentLabel = newLabels.get(lang);
        // If there isn't any label for that language, put the alias there
        if (currentLabel == null) {
            newLabels.put(lang, new NameWithUpdate(alias, true));
        // If the new alias is equal to the current label, skip it
        } else if (!currentLabel.value.equals(alias)) {
        	if (currentAliasesUpdate == null) {
        		currentAliasesUpdate = new AliasesWithUpdate(new ArrayList<MonolingualTextValue>(), true);
        	}
        	List<MonolingualTextValue> currentAliases = currentAliasesUpdate.aliases;
        	if(!currentAliases.contains(alias)) {
        		currentAliases.add(alias);
        		currentAliasesUpdate.added.add(alias);
        		currentAliasesUpdate.write = true;
        	}
        	newAliases.put(lang, currentAliasesUpdate);
        }
    }
810612
@Deprecated
    public static void createAlias(Client client, String alias, String index) throws Exception {
        logger.trace("createAlias({},{})", alias, index);
        AcknowledgedResponse response = client.admin().indices().prepareAliases().addAlias(index, alias).get();
        if (!response.isAcknowledged()) throw new Exception("Could not define alias [" + alias + "] for index [" + index + "].");
        logger.trace("/createAlias({},{})", alias, index);
    }
1330701
def alias(self, source: type, target: Any) -> Any:
        
        self.register(target, lambda c: c.resolve(source))
576365
private TableAlias createTableAlias(ClassDescriptor cld, List hints, String path)
    {
        TableAlias alias;
        boolean lookForExtents = false;

        if (!cld.getExtentClasses().isEmpty() && path.length() > 0)
        {
            lookForExtents = true;
        }

        String aliasName = String.valueOf(getAliasChar()) + m_aliasCount++; // m_pathToAlias.size();
        alias = new TableAlias(cld, aliasName, lookForExtents, hints);

        setTableAliasForPath(path, hints, alias);        
        return alias;
    }
1125070
def acceptAlias(decoratedFunction):
    """"""
    def wrapper(self, *args, **kwargs):
        SubAssert(isinstance(self, AliasBase))

        if len(args) > 0:
            key = args[0]
            if args[0] in self._aliases.keys():
                key = self._aliases[args[0]]
            return decoratedFunction(self, key, *args[1:], **kwargs)
        return decoratedFunction(self, *args, **kwargs)
    return wrapper
1127530
def filter_alias_create_namespace(namespace):
    
    def filter_string(s):
        return ' '.join(s.strip().split())

    namespace.alias_name = filter_string(namespace.alias_name)
    namespace.alias_command = filter_string(namespace.alias_command)
    return namespace
1014055
function runAlias(aliasName, directories, options, argv) {
	return new Promise((resolve, reject) => {
		const tasks = getAllAliases(options)[aliasName];
		if (!tasks) {
			reject(new MrmUnknownAlias(`Alias “${aliasName}” not found.`));
			return;
		}

		console.log(kleur.yellow(`Running alias ${aliasName}...`));

		promiseSeries(tasks, name => {
			return runTask(name, directories, options, argv);
		})
			.then(() => resolve())
			.catch(reject);
	});
}
192730
def using(self, alias):
        
        clone = self._clone()
        clone._index = alias
        return clone
1255198
def run_alias():
    
    mode = Path(sys.argv[0]).stem
    help = True if len(sys.argv) <= 1 else False
    if mode == 'lcc':
        sys.argv.insert(1, 'c')
    elif mode == 'lpython':
        sys.argv.insert(1, 'python')
    sys.argv.insert(1, 'run')
    if help:
        sys.argv.append('--help')
    main.main(prog_name='backend.ai')
663469
public void setAlias(String alias, String aliasPath)
	{
		m_alias = alias;
		m_userAlias = new UserAlias(alias, (String)getAttribute(), aliasPath);
	}
79000
function(name, realpath) {
        if (regAlias.test(name)) {
            if ($.isUndefined(realpath)) {
                return mapAlias[name];
            }
            mapAlias[name] = String(realpath).split(',');
        } else if ($.isObject(name)) {
            realpath = name.path;
            name = name;
            _.alias(name, realpath);
        }
    }
783743
function alias( $aliasName )
    {
        $aliasList = $this->aliasList();
        if ( !array_key_exists( $aliasName, $aliasList ) )
            return false;
        return $aliasList[$aliasName];
    }
82082
def add_alias(self, alias):
        
        objs = object_session(self)
        
        if isinstance(alias, list):
            raise NotImplementedError
        elif isinstanceofany(alias, (str, unicode)):
            a = SymbolAlias(self, alias)
            self.aliases.append(a)
            objs.add(a)
388801
def configure_alias(graph, ns, mappings):
    
    convention = AliasConvention(graph)
    convention.configure(ns, mappings)
564619
def create_domainalias(self, domainid, data):
        """"""
        return self.api_call(
            ENDPOINTS['domainaliases']['new'],
            dict(domainid=domainid),
            body=data)
110718
def set_alias(cls, domain, login, aliases):
        """"""
        return cls.call('domain.mailbox.alias.set', domain, login, aliases)