telemetry.internal.util.path_set
index
telemetry/internal/util/path_set.py

# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

 
Modules
       
collections
os

 
Classes
       
_abcoll.MutableSet(_abcoll.Set)
PathSet

 
class PathSet(_abcoll.MutableSet)
    A set of paths.
 
All mutation methods can take both directories or individual files, but the
iterator yields the individual files. All paths are automatically normalized.
 
 
Method resolution order:
PathSet
_abcoll.MutableSet
_abcoll.Set
_abcoll.Sized
_abcoll.Iterable
_abcoll.Container
__builtin__.object

Methods defined here:
__contains__(self, path)
__init__(self, iterable=None)
__iter__(self)
__len__(self)
add(self, path)
discard(self, path)

Data and other attributes defined here:
__abstractmethods__ = frozenset([])

Methods inherited from _abcoll.MutableSet:
__iand__(self, it)
__ior__(self, it)
__isub__(self, it)
__ixor__(self, it)
clear(self)
This is slow (creates N new iterators!) but effective.
pop(self)
Return the popped value.  Raise KeyError if empty.
remove(self, value)
Remove an element. If not a member, raise a KeyError.

Methods inherited from _abcoll.Set:
__and__(self, other)
__eq__(self, other)
__ge__(self, other)
__gt__(self, other)
__le__(self, other)
__lt__(self, other)
__ne__(self, other)
__or__(self, other)
__sub__(self, other)
__xor__(self, other)
isdisjoint(self, other)
Return True if two sets have a null intersection.

Data and other attributes inherited from _abcoll.Set:
__hash__ = None

Class methods inherited from _abcoll.Sized:
__subclasshook__(cls, C) from abc.ABCMeta

Data descriptors inherited from _abcoll.Sized:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from _abcoll.Sized:
__metaclass__ = <class 'abc.ABCMeta'>
Metaclass for defining Abstract Base Classes (ABCs).
 
Use this metaclass to create an ABC.  An ABC can be subclassed
directly, and then acts as a mix-in class.  You can also register
unrelated concrete classes (even built-in classes) and unrelated
ABCs as 'virtual subclasses' -- these and their descendants will
be considered subclasses of the registering ABC by the built-in
issubclass() function, but the registering ABC won't show up in
their MRO (Method Resolution Order) nor will method
implementations defined by the registering ABC be callable (not
even via super()).