blob: 6be2402a04828015610ab56e86edaa501fed3d07 [file] [log] [blame]
# Copyright 2014 Google Inc.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import collections
import types
# The goal of this class is to store a set of unique items in the order in
# which they are inserted. This is important for the final makefile, where
# we want to make sure the image decoders are in a particular order. See
# images.gyp for more information.
class OrderedSet(object):
"""Ordered set of unique items that supports addition and removal.
Retains the order in which items are inserted.
def __init__(self):
self.__ordered_set = []
def add(self, item):
"""Add item, if it is not already in the set.
item is appended to the end if it is not already in the set.
item: The item to add.
if item not in self.__ordered_set:
def __contains__(self, item):
"""Whether the set contains item.
item: The item to search for in the set.
bool: Whether the item is in the set.
return item in self.__ordered_set
def __iter__(self):
"""Iterator for the set.
return self.__ordered_set.__iter__()
def remove(self, item):
Remove item from the set.
item: Item to be removed.
ValueError if item is not in the set.
def __len__(self):
"""Number of items in the set.
return len(self.__ordered_set)
def __getitem__(self, index):
"""Return item at index.
return self.__ordered_set[index]
def reset(self):
"""Reset to empty.
self.__ordered_set = []
def set(self, other):
"""Replace this ordered set with another.
other: OrderedSet to replace this one. After this call, this OrderedSet
will contain exactly the same elements as other.
self.__ordered_set = list(other.__ordered_set)
# These are not parsed by gyp, but set manually.
class VarsDict(collections.namedtuple('VarsDict', VAR_NAMES)):
"""Custom class for storing the arguments to variables.
Can also be treated as a dictionary with fixed keys.
__slots__ = ()
def __new__(cls):
lists = []
# TODO (scroggo): Is there a better way add N items?
for __unused__ in range(len(VAR_NAMES)):
return tuple.__new__(cls, lists)
def keys(self):
"""Return the field names as strings.
return self._fields
def __getitem__(self, index):
"""Return an item, indexed by a number or a string.
if type(index) == types.IntType:
# Treat the index as an array index into a tuple.
return tuple.__getitem__(self, index)
if type(index) == types.StringType:
# Treat the index as a key into a dictionary.
return eval('self.%s' % index)
return None
def intersect(var_dict_list):
"""Compute intersection of VarsDicts.
Find the intersection of a list of VarsDicts and trim each input to its
unique entries.
var_dict_list: list of VarsDicts. WARNING: each VarsDict will be
modified in place, to remove the common elements!
VarsDict containing list entries common to all VarsDicts in
intersection = VarsDict()
# First VarsDict
var_dict_a = var_dict_list[0]
# The rest.
other_var_dicts = var_dict_list[1:]
for key in var_dict_a.keys():
# Copy A's list, so we can continue iterating after modifying the original.
a_list = list(var_dict_a[key])
for item in a_list:
# If item is in all lists, add to intersection, and remove from all.
in_all_lists = True
for var_dict in other_var_dicts:
if not item in var_dict[key]:
in_all_lists = False
if in_all_lists:
for var_dict in var_dict_list:
return intersection