Filters Named to contain a name from the input set.
@param name name to require
@return constraint
182779
public static Constraint nameEquals(String... name)
	{
		return new Field("Named/name", Field.Operation.INTERSECT,
			new HashSet<String>(Arrays.asList(name)));
	}
87586
public Set<Property> getProperties(String name) {
        return this.properties.stream().filter(property -> property.getName().equals(name)).collect(Collectors.toSet());
    }
544735
public Map<String,String> getMapFilter(String name) {
        String value = filters.get(name);
        if (value == null)
            return null;
        Map<String,String> map = new LinkedHashMap<>();
        if (value.startsWith("{") && value.endsWith("}")) {
            for (String entry : value.substring(1, value.length() - 1).split(",")) {
                int eq = entry.indexOf('=');
                if (eq > 0 && eq < entry.length() - 1) {
                    String key = entry.substring(0, eq).trim();
                    String val = entry.substring(eq + 1);
                    if ((val.startsWith("\"") && val.endsWith("\"")) || (val.startsWith("'") && val.endsWith("'")) && val.length() > 1) {
                        val = val.substring(1, val.length() - 1);
                    }
                    else {
                        val = val.trim();
                    }
                    map.put(key, val);
                }
            }
        }
        return map.isEmpty() ? null : map;
    }
1011443
public function dropIndex($name, $constraint = false)
    {
        if (!$constraint && !$this->hasIndex($name)) {
            return $this;
        }

        if ($constraint) {
            $query = PostgresqlGrammar::dropConstraint($this->getName(), $name, true, 'RESTRICT');
        } else {
            $query = PostgresqlGrammar::dropIndex($name, true);
        }

        $this->db->setQuery($query)->execute();

        return $this->reset();
    }
544669
public T get(String name) {
        if (m_items == null) {
            return null;
        }
        return m_items.get(name.toUpperCase());
    }
1059919
public static <T extends Named> Collection<T> matchName(Collection<T> values, String name) {
        List<T> result = new ArrayList<>();
        for (T value : values) {
            if (value == null) {
                continue;
            }
            if (startsWithIgnoreCase(value.getName(), name)) {
                result.add(value);
            }
        }
        return result;
    }
380972
public Optional<String> getAlias(final String name) {
        if (containStar) {
            return Optional.absent();
        }
        String rawName = SQLUtil.getExactlyValue(name);
        for (SelectItem each : items) {
            if (SQLUtil.getExactlyExpression(rawName).equalsIgnoreCase(SQLUtil.getExactlyExpression(SQLUtil.getExactlyValue(each.getExpression())))) {
                return each.getAlias();
            }
            if (rawName.equalsIgnoreCase(each.getAlias().orNull())) {
                return Optional.of(rawName);
            }
        }
        return Optional.absent();
    }
869833
public static @Nonnull Predicate nameIs(final @Nonnull String name) {
        return new Predicate() {
            @Override
            public boolean isValid(@Nonnull ProcessThread<?, ?, ?> thread) {
                return thread.getName().equals(name);
            }
        };
    }
774423
public StructuredQueryDefinition containerConstraint(String constraintName, StructuredQueryDefinition query) {
    checkQuery(query);
    return new ContainerConstraintQuery(constraintName, query);
  }
424271
public XExtension getByName(String name) {
                for (XExtension ext : extensionList) {
                        if (ext.getName().equals(name)) {
                                return ext;
                        }
                }
                return null;
        }
869275
protected function createSelectWithConstraint($name)
    {
        return [explode(':', $name)[0], function ($query) use ($name) {
            $query->select(explode(',', explode(':', $name)[1]));
        }];
    }
10986
@SuppressWarnings("unchecked")
  public <T extends ResponseFilter> T responseFilter(String name) {
    return (T) responseFilters.get(name);
  }
823961
public DataCenterFilter nameContains(String... names) {
        allItemsNotNull(names, "Name keywords");

        predicate = predicate.and(combine(
            DataCenterMetadata::getName, in(asList(names), Predicates::containsIgnoreCase)
        ));

        return this;
    }
229850
public GroupFilter nameContains(String... subStrings) {
        checkNotNull(subStrings, "Name match criteria must be not a null");

        predicate = predicate.and(combine(
            GroupMetadata::getName, in(asList(subStrings), Predicates::containsIgnoreCase)
        ));

        return this;
    }
9180
public static function create(string $name, array $constraints): ValidationPropertyMappingBuilderInterface
    {
        $self = new self();
        $self->name = $name;

        $self->constraints = [];
        foreach ($constraints as $constraint) {
            $self->addConstraint($constraint);
        }

        return $self;
    }
627272
public CompilerInput getByName(String name) {
    for (CompilerInput input : inputs) {
      if (name.equals(input.getName())) {
        return input;
      }
    }
    return null;
  }
1229503
public GetPresetResponse getPreset(String name) {
        GetPresetRequest request = new GetPresetRequest();
        request.setName(name);
        return getPreset(request);
    }