Returns whether the current {@link Links} contain all given {@link Link}s (but potentially others).

@param links must not be {@literal null}.
@return
764200
public boolean contains(Iterable<Link> links) {
		return this.links.containsAll(Links.of(links).toList());
	}
598501
public final boolean contains(CharSequence s) {

        int cp = getSingleCP(s);
        if (cp < 0) {
            return strings.contains(s.toString());
        } else {
            return contains(cp);
        }
    }
1269634
public static boolean isLink(Area a)
    {
        for (Box box : a.getBoxes())
        {
            if (box.getAttribute("href") != null)
                return true;
        }
        return false;
    }
954545
public HtmlPolicyBuilder requireRelsOnLinks(String... linkValues) {
    this.invalidateCompiledState();
    if (this.extraRelsForLinks == null) {
      this.extraRelsForLinks = Sets.newLinkedHashSet();
    }
    for (String linkValue : linkValues) {
      linkValue = HtmlLexer.canonicalName(linkValue);
      Preconditions.checkArgument(
          !Strings.containsHtmlSpace(linkValue),
          "spaces in input.  use f(\"foo\", \"bar\") not f(\"foo bar\")");
      this.extraRelsForLinks.add(linkValue);
    }
    if (this.skipRelsForLinks != null) {
      this.skipRelsForLinks.removeAll(this.extraRelsForLinks);
    }
    return this;
  }
980135
public static boolean contains(Object src, Object... dests) {
        if (dests == null) {
            throw new NullPointerException("dest must not be null");
        }

        if (src == null) {
            return false;
        }

        for (Object dest : dests) {
            if (src == dest || src.equals(dest)) {
                return true;
            }
        }
        return false;
    }
1354044
public static <T> List<T> list(boolean isLinked) {
		return isLinked ? new LinkedList<T>() : new ArrayList<T>();
	}
1011929
@SuppressWarnings("unchecked")
	public T add(Link link) {

		Assert.notNull(link, "Link must not be null!");

		this.links.add(link);

		return (T) this;
	}
748331
private static boolean exists(File link) {
        File[] kids = link.getParentFile().listFiles();
        return kids != null && Arrays.asList(kids).contains(link);
    }
519626
public static boolean isIanaRel(String relation) {

		Assert.notNull(relation, "Link relation must not be null!");

		return LINK_RELATIONS.stream() //
				.anyMatch(it -> it.value().equalsIgnoreCase(relation));
	}
553063
public final boolean contains(Object s)
  {

    for (int i = 0; i < m_firstFree; i++)
    {
      if (m_map[i] == s)
        return true;
    }

    return false;
  }
358735
protected HalRepresentation add(final Links links) {
        this.links = this.links != null
                ? copyOf(this.links).with(links).build()
                : links.using(this.curies);
        if (embedded != null) {
            embedded = embedded.using(this.curies);
        }
        return this;
    }
1167223
public void setLinkSpecifiers(java.util.Collection<TypedLinkSpecifier> linkSpecifiers) {
        if (linkSpecifiers == null) {
            this.linkSpecifiers = null;
            return;
        }

        this.linkSpecifiers = new java.util.ArrayList<TypedLinkSpecifier>(linkSpecifiers);
    }
909411
public void setParentLinks(java.util.Collection<ObjectIdentifierAndLinkNameTuple> parentLinks) {
        if (parentLinks == null) {
            this.parentLinks = null;
            return;
        }

        this.parentLinks = new java.util.ArrayList<ObjectIdentifierAndLinkNameTuple>(parentLinks);
    }
93650
public static DefaultListOperation<ContentKeyInfo> list(
            LinkInfo<ContentKeyInfo> link) {
        return new DefaultListOperation<ContentKeyInfo>(link.getHref(),
                new GenericType<ListResult<ContentKeyInfo>>() {
                });
    }
1275091
public boolean isSatisfiedby(Collection<ClientlibLink> links) {
        for (ClientlibLink link : links) if (isSatisfiedby(link)) return true;
        return false;
    }
437342
public Links and(Iterable<Link> links) {

		List<Link> newLinks = new ArrayList<>(this.links);
		links.forEach(newLinks::add);

		return Links.of(newLinks);
	}
814760
public Links and(Link... links) {

		Assert.notNull(links, "Links must not be null!");

		return and(Arrays.asList(links));
	}