removing that same alias [alias] of [indice]
more detail see :
* https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html
@param indice
@param alias
@return
4813
public String removeAlias(String indice,String alias){
		String removeAlias = new StringBuilder().append("{\"actions\": [{\"remove\": {\"index\":\"").append(indice).append("\",\"alias\": \"").append(alias).append("\"}}]}").toString();
		return this.client.executeHttp("_aliases",removeAlias,ClientUtil.HTTP_POST);
	}
732617
public RelaxedDataBinder withAlias(String name, String... alias) {
        for (String value : alias) {
            this.nameAliases.add(name, value);
        }
        return this;
    }
738370
protected String getProperty(String alias) {
		String k = resolveKey(alias);
		return k == null ? null : resolver.getProperty(k);
	}
871056
public OvhOperation serviceName_output_elasticsearch_alias_aliasId_index_POST(String serviceName, String aliasId, String indexId) throws IOException {
		String qPath = "/dbaas/logs/{serviceName}/output/elasticsearch/alias/{aliasId}/index";
		StringBuilder sb = path(qPath, serviceName, aliasId);
		HashMap<String, Object>o = new HashMap<String, Object>();
		addBody(o, "indexId", indexId);
		String resp = exec(qPath, "POST", sb.toString(), o);
		return convertTo(resp, OvhOperation.class);
	}
670124
public int swapIndex(final String index,
                       final String alias) throws IndexException {
    //IndicesAliasesResponse resp = null;
    try {
      /* index is the index we were just indexing into
       */

      final IndicesAdminClient idx = getAdminIdx();

      final GetAliasesRequestBuilder igarb = idx.prepareGetAliases(
              alias);

      final ActionFuture<GetAliasesResponse> getAliasesAf =
              idx.getAliases(igarb.request());
      final GetAliasesResponse garesp = getAliasesAf.actionGet();

      final ImmutableOpenMap<String, List<AliasMetaData>> aliasesmeta =
              garesp.getAliases();

      final IndicesAliasesRequestBuilder iarb = idx.prepareAliases();

      final Iterator<String> it = aliasesmeta.keysIt();

      while (it.hasNext()) {
        final String indexName = it.next();

        for (final AliasMetaData amd: aliasesmeta.get(indexName)) {
          if(amd.getAlias().equals(alias)) {
            iarb.removeAlias(indexName, alias);
          }
        }
      }

      iarb.addAlias(index, alias);

      final ActionFuture<IndicesAliasesResponse> af =
              idx.aliases(iarb.request());

      /*resp = */af.actionGet();

      return 0;
    } catch (final ElasticsearchException ese) {
      // Failed somehow
      error(ese);
      return -1;
    } catch (final IndexException ie) {
      throw ie;
    } catch (final Throwable t) {
      throw new IndexException(t);
    }
  }
987299
public boolean aliasExists(String alias) {
        try {
            final JestResult result = jestClient.execute(new GetSettings.Builder().addIndex(alias).build());
            return result.isSucceeded() && !Iterators.contains(result.getJsonObject().fieldNames(), alias);
        } catch (IOException e) {
            throw new ElasticsearchException("Couldn't check existence of alias " + alias, e);
        }
    }
71633
public function removeAlias($alias)
    {
        if (array_key_exists($alias, $this->aliases)) {
            unset($this->aliases[$alias]);
        }

        return $this;
    }
835767
public void deleteAbstractAliasDestinationHandler(AbstractAliasDestinationHandler abstractAliasDestinationHandler)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "deleteAbstractAliasDestinationHandler");
    
    //The destination is an alias or a foreign destination, so its not persisted
    //It is removed immediately from the appropriate index
    if(abstractAliasDestinationHandler instanceof BusHandler)
    {
      _foreignBusIndex.remove(abstractAliasDestinationHandler);
    }
    else
    {
      _destinationIndex.remove(abstractAliasDestinationHandler);
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "deleteAbstractAliasDestinationHandler");
  }
132516
public Integer addWithAlias(String alias, V value) {
        synchronized (dataList) {
            dataList.add(value);
            return aliasIndexMap.put(alias, dataList.size() - 1);
        }
    }
113882
@Override
    public String matchPredicateOperand(String alias) {
        Objects.requireNonNull(alias, "alias cannot be null");
        // alias.identifier
        return alias + "." + idFieldName;
    }
395347
def _alias_id(self, primary_id, equivalent_id):
        """"""
        pkg_name = primary_id.get_identifier_namespace().split('.')[0]
        obj_name = primary_id.get_identifier_namespace().split('.')[1]
        collection = JSONClientValidated(pkg_name,
                                         collection=obj_name,
                                         runtime=self._runtime)
        collection.find_one({'_id': ObjectId(primary_id.get_identifier())})  # to raise NotFound
        collection = JSONClientValidated('id',
                                         collection=pkg_name + 'Ids',
                                         runtime=self._runtime)
        try:
            result = collection.find_one({'aliasIds': {'$in': [str(equivalent_id)]}})
        except errors.NotFound:
            pass
        else:
            result['aliasIds'].remove(str(equivalent_id))
            collection.save(result)
        try:
            id_map = collection.find_one({'_id': str(primary_id)})
        except errors.NotFound:
            collection.insert_one({'_id': str(primary_id), 'aliasIds': [str(equivalent_id)]})
        else:
            id_map['aliasIds'].append(str(equivalent_id))
            collection.save(id_map)
192730
def using(self, alias):
        
        clone = self._clone()
        clone._index = alias
        return clone
935237
public DslExpression<T> as(String alias) {
        return as(ExpressionUtils.path(getType(), alias));
    }
938384
public void setAlias(String alias) {
        this.alias = (alias != null && alias.isEmpty() == false ? alias : null);
    }
109198
public void setAlias(String alias)
	{
		if (alias == null || alias.trim().equals(""))
		{
			m_alias = null;
		}
		else
		{
			m_alias = alias;
		}

		// propagate to SelectionCriteria,not to Criteria
		for (int i = 0; i < m_criteria.size(); i++)
		{
			if (!(m_criteria.elementAt(i) instanceof Criteria))
			{
				((SelectionCriteria) m_criteria.elementAt(i)).setAlias(m_alias);
			}
		}
	}
716223
public function removeAlias($alias)
    {
        $this->validateAlias($alias);
        if (!$this->aliases->has($alias)) {
            throw new Exception\AliasNotFoundException(sprintf('The "%s" item alias does not exist.', $alias));
        }

        $this->aliases->remove($alias);
    }
601328
public boolean existIndice(String indiceName) throws ElasticSearchException{
		try {
			executeHttp(indiceName, ClientInterface.HTTP_HEAD);
			return true;
		}
		catch(ElasticSearchException e){
			return ResultUtil.hand404HttpRuntimeException(e,boolean.class,ResultUtil.OPERTYPE_existIndice);
		}

	}