| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259 |
- # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
- #
- # Permission to use, copy, modify, and distribute this software and its
- # documentation for any purpose with or without fee is hereby granted,
- # provided that the above copyright notice and this permission notice
- # appear in all copies.
- #
- # THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
- # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
- # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
- # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- """A simple Set class."""
- class Set(object):
- """A simple set class.
- Sets are not in Python until 2.3, and rdata are not immutable so
- we cannot use sets.Set anyway. This class implements subset of
- the 2.3 Set interface using a list as the container.
- @ivar items: A list of the items which are in the set
- @type items: list"""
- __slots__ = ['items']
- def __init__(self, items=None):
- """Initialize the set.
- @param items: the initial set of items
- @type items: any iterable or None
- """
- self.items = []
- if items is not None:
- for item in items:
- self.add(item)
- def __repr__(self):
- return "dns.simpleset.Set(%s)" % repr(self.items)
- def add(self, item):
- """Add an item to the set."""
- if item not in self.items:
- self.items.append(item)
- def remove(self, item):
- """Remove an item from the set."""
- self.items.remove(item)
- def discard(self, item):
- """Remove an item from the set if present."""
- try:
- self.items.remove(item)
- except ValueError:
- pass
- def _clone(self):
- """Make a (shallow) copy of the set.
- There is a 'clone protocol' that subclasses of this class
- should use. To make a copy, first call your super's _clone()
- method, and use the object returned as the new instance. Then
- make shallow copies of the attributes defined in the subclass.
- This protocol allows us to write the set algorithms that
- return new instances (e.g. union) once, and keep using them in
- subclasses.
- """
- cls = self.__class__
- obj = cls.__new__(cls)
- obj.items = list(self.items)
- return obj
- def __copy__(self):
- """Make a (shallow) copy of the set."""
- return self._clone()
- def copy(self):
- """Make a (shallow) copy of the set."""
- return self._clone()
- def union_update(self, other):
- """Update the set, adding any elements from other which are not
- already in the set.
- @param other: the collection of items with which to update the set
- @type other: Set object
- """
- if not isinstance(other, Set):
- raise ValueError('other must be a Set instance')
- if self is other:
- return
- for item in other.items:
- self.add(item)
- def intersection_update(self, other):
- """Update the set, removing any elements from other which are not
- in both sets.
- @param other: the collection of items with which to update the set
- @type other: Set object
- """
- if not isinstance(other, Set):
- raise ValueError('other must be a Set instance')
- if self is other:
- return
- # we make a copy of the list so that we can remove items from
- # the list without breaking the iterator.
- for item in list(self.items):
- if item not in other.items:
- self.items.remove(item)
- def difference_update(self, other):
- """Update the set, removing any elements from other which are in
- the set.
- @param other: the collection of items with which to update the set
- @type other: Set object
- """
- if not isinstance(other, Set):
- raise ValueError('other must be a Set instance')
- if self is other:
- self.items = []
- else:
- for item in other.items:
- self.discard(item)
- def union(self, other):
- """Return a new set which is the union of I{self} and I{other}.
- @param other: the other set
- @type other: Set object
- @rtype: the same type as I{self}
- """
- obj = self._clone()
- obj.union_update(other)
- return obj
- def intersection(self, other):
- """Return a new set which is the intersection of I{self} and I{other}.
- @param other: the other set
- @type other: Set object
- @rtype: the same type as I{self}
- """
- obj = self._clone()
- obj.intersection_update(other)
- return obj
- def difference(self, other):
- """Return a new set which I{self} - I{other}, i.e. the items
- in I{self} which are not also in I{other}.
- @param other: the other set
- @type other: Set object
- @rtype: the same type as I{self}
- """
- obj = self._clone()
- obj.difference_update(other)
- return obj
- def __or__(self, other):
- return self.union(other)
- def __and__(self, other):
- return self.intersection(other)
- def __add__(self, other):
- return self.union(other)
- def __sub__(self, other):
- return self.difference(other)
- def __ior__(self, other):
- self.union_update(other)
- return self
- def __iand__(self, other):
- self.intersection_update(other)
- return self
- def __iadd__(self, other):
- self.union_update(other)
- return self
- def __isub__(self, other):
- self.difference_update(other)
- return self
- def update(self, other):
- """Update the set, adding any elements from other which are not
- already in the set.
- @param other: the collection of items with which to update the set
- @type other: any iterable type"""
- for item in other:
- self.add(item)
- def clear(self):
- """Make the set empty."""
- self.items = []
- def __eq__(self, other):
- # Yes, this is inefficient but the sets we're dealing with are
- # usually quite small, so it shouldn't hurt too much.
- for item in self.items:
- if item not in other.items:
- return False
- for item in other.items:
- if item not in self.items:
- return False
- return True
- def __ne__(self, other):
- return not self.__eq__(other)
- def __len__(self):
- return len(self.items)
- def __iter__(self):
- return iter(self.items)
- def __getitem__(self, i):
- return self.items[i]
- def __delitem__(self, i):
- del self.items[i]
- def issubset(self, other):
- """Is I{self} a subset of I{other}?
- @rtype: bool
- """
- if not isinstance(other, Set):
- raise ValueError('other must be a Set instance')
- for item in self.items:
- if item not in other.items:
- return False
- return True
- def issuperset(self, other):
- """Is I{self} a superset of I{other}?
- @rtype: bool
- """
- if not isinstance(other, Set):
- raise ValueError('other must be a Set instance')
- for item in other.items:
- if item not in self.items:
- return False
- return True
|