Checks if an alias was entered twice.<p>

@param aliasName to check
@return true if it was defined double
340891
boolean isDoubleAlias(String aliasName) {

        CmsSiteMatcher testAlias = new CmsSiteMatcher(aliasName);
        int count = 0;
        for (Component c : m_aliases) {
            if (c instanceof CmsRemovableFormRow<?>) {
                String alName = (String)((CmsRemovableFormRow<? extends AbstractField<?>>)c).getInput().getValue();
                if (testAlias.equals(new CmsSiteMatcher(alName))) {
                    count++;
                }
            }
        }
        return count > 1;
    }
1200201
public void alias( Object ...args ) {
        if( args.length % 2 == 1 )
            throw new RuntimeException("Even number of arguments expected");

        for (int i = 0; i < args.length; i += 2) {
            aliasGeneric( args[i], (String)args[i+1]);
        }
    }
345773
def has_alias(self, header):
        """"""
        try:
            # Force to lower case (issue #1126)
            return self._limits[self.plugin_name + '_' + header.lower() + '_' + 'alias'][0]
        except (KeyError, IndexError):
            # logger.debug("No alias found for {}".format(header))
            return None
1357515
public boolean hasSlotIsEqual(final String slotName, final String value) {
        final String slotValue = getSlotValue(slotName);
        return (slotValue != null && slotValue.equals(value)) ||
                slotValue == value;
    }
711790
private boolean tryReplacingAliasingAssignment(Ref alias, Node aliasLhsNode) {
    // either VAR/CONST/LET or ASSIGN.
    Node assignment = aliasLhsNode.getParent();
    if (!NodeUtil.isNameDeclaration(assignment) && NodeUtil.isExpressionResultUsed(assignment)) {
      // e.g. don't change "if (alias = someVariable)" to "if (alias = null)"
      // TODO(lharker): instead replace the entire assignment with the RHS - "alias = x" becomes "x"
      return false;
    }
    Node aliasParent = alias.getNode().getParent();
    aliasParent.replaceChild(alias.getNode(), IR.nullNode());
    alias.name.removeRef(alias);
    codeChanged = true;
    compiler.reportChangeToEnclosingScope(aliasParent);
    return true;
  }
11113
protected static void registerAlias(Class<?> parent, String alias, String cname) {
    Entry e = data.get(parent);
    assert (e != null);
    e.addAlias(alias, cname);
  }
91702
public static boolean isTableSegment(String qualifiedName) {
        Preconditions.checkNotNull(qualifiedName);
        String[] tokens = qualifiedName.split("[/]");
        Preconditions.checkArgument(tokens.length > 2);

        return tokens[1].equals(TABLES);
    }
113882
@Override
    public String matchPredicateOperand(String alias) {
        Objects.requireNonNull(alias, "alias cannot be null");
        // alias.identifier
        return alias + "." + idFieldName;
    }
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);
        }
    }
835898
public boolean containsDuplicateIdentities() {
        List<Identity> checkedIdentities = new LinkedList<>();
        for (Identity i : identities) {
            for (Identity i2 : checkedIdentities) {
                if (i.equals(i2))
                    return true;
            }
            checkedIdentities.add(i);
        }
        return false;
    }
783743
function alias( $aliasName )
    {
        $aliasList = $this->aliasList();
        if ( !array_key_exists( $aliasName, $aliasList ) )
            return false;
        return $aliasList[$aliasName];
    }
77513
public boolean fnameExists(final String fname) {
        boolean rslt = false; // default
        try {
            final ITenant tenant = getTenantByFName(fname);
            rslt = tenant != null;
        } catch (IllegalArgumentException iae) {
            // This exception is completely fine;  it simply
            // means there is no tenant with this fname.
            rslt = false;
        }
        return rslt;
    }
963091
public static boolean isSameType(@Nonnull TypeMirror t1, @Nonnull TypeMirror t2) {
        String t1Name = toUniqueString(t1);
        String t2Name = toUniqueString(t2);

        return t1Name.equals(t2Name);
    }
979008
public void putAlias(String alias) throws JSONException {
        if (alias != null) {
            this.alias = alias;
            this.put(Defines.LinkParam.Alias.getKey(), alias);
        }
    }
553508
public static boolean hasExplicitOperationName(String operationName) {
        return operationName != null && !OPERATION_NAME_TRACED.equals(operationName) && !OPERATION_NAME_UNTRACED.equals(operationName);
    }
1200755
private boolean areTypeNamesEqual(String name1, String name2) {
    return name1.replace('$', '.').equals(name2.replace('$', '.'));
  }
72195
public boolean hasUniqueLongOption(String optionName) {
        if(hasLongOption(optionName)) {
            for(ProcessedOption o : getOptions()) {
                if(o.name().startsWith(optionName) && !o.name().equals(optionName))
                    return false;
            }
            return true;
        }
        return false;
    }