Return whether this collection contains all items.

        >>> Unique(['spam', 'eggs']).issuperset(['spam', 'spam', 'spam'])
        True
543662
def issuperset(self, items):
        
        return all(_compat.map(self._seen.__contains__, items))
1249530
public boolean isSubset(IntArray subset)
  {
    int []subData = subset._data;
    
    for (int i = subset._size - 1; i >= 0; i--) {
      if (! contains(subData[i]))
        return false;
    }

    return true;
  }
420558
def unique(list1, list2):
    
    set2 = set(list2)
    list1_unique = [x for x in tqdm(list1, desc='Unique', total=len(list1)) if x not in set2]
    return list1_unique
933508
def is_unique(self):
        """"""
        if self._is_unique is None:
            t = self.values[:-1] == self.values[1:]  # type: np.ndarray
            self._is_unique = ~np.any(t)
        return self._is_unique
434505
@Override
	public boolean containsAll(Collection<?> collection) {
		if (booleanTerms == null) {
			return false;
		}
		return booleanTerms.containsAll(collection);
	}
380604
def is_correct(self):
        
        state = True

        # Make members unique, remove duplicates
        if self.members:
            self.members = list(set(self.members))

        if self.unknown_members:
            for member in self.unknown_members:
                msg = "[%s::%s] as %s, got unknown member '%s'" % (
                    self.my_type, self.get_name(), self.__class__.my_type, member
                )
                self.add_error(msg)
            state = False

        return super(Itemgroup, self).is_correct() and state
33051
private boolean hasSameIndices(Collection<?> c) {
		return c != null 
				&& (c instanceof PairSet) 
				&& (allTransactions == ((PairSet) c).allTransactions)
				&& (allItems == ((PairSet) c).allItems);
	}
161683
def unique_list(seq):
    
    seen = set()
    seen_add = seen.add
    return [x for x in seq if not (x in seen or seen_add(x))]
411630
def is_list_of_list(item):
    
    if (
        type(item) in (list, tuple)
        and len(item)
        and isinstance(item[0], (list, tuple))
    ):
        return True
    return False
880643
def uniqued(iterable):
    
    seen = set()
    add = seen.add
    return [i for i in iterable if i not in seen and not add(i)]
689623
def contains(self, data):
        
        for item in self:
            if item.data() == data:
                return True
        return False
368583
def unique(iterable):
    """"""
    seen = set()
    for item in iterable:
        if item not in seen:
            seen.add(item)
            yield item
77702
def titles(self, unique=False):
        
        if unique:
            return tools.uniqued(s.title for s in self._items)
        return [s.title for s in self._items]
192789
public boolean containsAll(Collection<?> c) {
        int n = c.size();
        final Iterator<?> i = c.iterator();
        while (n-- != 0)
            if (!contains(i.next())) return false;
        return true;
    }
790695
def unique(iterable):
    
    """
    d = {}
    return (d.setdefault(x,x) for x in iterable if x not in d)
231564
def iflag_unique_items(list_):
    
    seen = set()
    def unseen(item):
        if item in seen:
            return False
        seen.add(item)
        return True
    flag_iter = (unseen(item) for item in list_)
    return flag_iter
287997
public boolean isSuperset(SmallSet<E> other) {
        if (this.list.size() < other.list.size()) {
            return false;
        }
        int j = 0;
        for (int i=0; i<list.size() && j<other.list.size(); i++) {
            E e1 = this.list.get(i);
            E e2 = other.list.get(j);
            int diff = e1.compareTo(e2);
            if (diff == 0) {
                // Equal entries. Just continue.
                j++;
                continue;
            } else if (diff > 0) {
                // e1 is greater than e2, which means e2 must not appear in this.list.
                return false;
            } else {
                // e1 is less than e2, so e2 might appear later in this.list.
                continue;
            }
        }
        if (j == other.list.size()) {
            return true;
        } else {
            return false;
        }
    }