# __COPYRIGHT__ # # Benchmarks for testing various possible implementations # of the is_Dict(), is_List() and is_String() functions in # src/engine/SCons/Util.py. import types from UserDict import UserDict from UserList import UserList try: from UserString import UserString except ImportError: # "Borrowed" from the Python 2.2 UserString module # and modified slightly for use with SCons. class UserString: def __init__(self, seq): if isinstance(seq, str): self.data = seq elif isinstance(seq, UserString): self.data = seq.data[:] else: self.data = str(seq) def __str__(self): return str(self.data) def __repr__(self): return repr(self.data) def __int__(self): return int(self.data) def __long__(self): return long(self.data) def __float__(self): return float(self.data) def __complex__(self): return complex(self.data) def __hash__(self): return hash(self.data) def __cmp__(self, s): if isinstance(s, UserString): return cmp(self.data, s.data) else: return cmp(self.data, s) def __contains__(self, char): return char in self.data def __len__(self): return len(self.data) def __getitem__(self, index): return self.__class__(self.data[index]) def __getslice__(self, start, end): start = max(start, 0); end = max(end, 0) return self.__class__(self.data[start:end]) def __add__(self, other): if isinstance(other, UserString): return self.__class__(self.data + other.data) elif is_String(other): return self.__class__(self.data + other) else: return self.__class__(self.data + str(other)) def __radd__(self, other): if is_String(other): return self.__class__(other + self.data) else: return self.__class__(str(other) + self.data) def __mul__(self, n): return self.__class__(self.data*n) __rmul__ = __mul__ InstanceType = types.InstanceType DictType = dict ListType = list StringType = str try: unicode except NameError: UnicodeType = None else: UnicodeType = unicode # The original implementations, pretty straightforward checks for the # type of the object and whether it's an instance of the corresponding # User* type. def original_is_Dict(e): return isinstance(e, dict) or isinstance(e, UserDict) def original_is_List(e): return isinstance(e, list) or isinstance(e, UserList) if UnicodeType is not None: def original_is_String(e): return isinstance(e, str) \ or isinstance(e, unicode) \ or isinstance(e, UserString) else: def original_is_String(e): return isinstance(e, str) or isinstance(e, UserString) # New candidates that explicitly check for whether the object is an # InstanceType before calling isinstance() on the corresponding User* # type. def checkInstanceType_is_Dict(e): return isinstance(e, dict) or \ (isinstance(e, types.InstanceType) and isinstance(e, UserDict)) def checkInstanceType_is_List(e): return isinstance(e, list) \ or (isinstance(e, types.InstanceType) and isinstance(e, UserList)) if UnicodeType is not None: def checkInstanceType_is_String(e): return isinstance(e, str) \ or isinstance(e, unicode) \ or (isinstance(e, types.InstanceType) and isinstance(e, UserString)) else: def checkInstanceType_is_String(e): return isinstance(e, str) \ or (isinstance(e, types.InstanceType) and isinstance(e, UserString)) # Improved candidates that cache the type(e) result in a variable # before doing any checks. def cache_type_e_is_Dict(e): t = type(e) return t is dict or \ (t is types.InstanceType and isinstance(e, UserDict)) def cache_type_e_is_List(e): t = type(e) return t is list \ or (t is types.InstanceType and isinstance(e, UserList)) if UnicodeType is not None: def cache_type_e_is_String(e): t = type(e) return t is str \ or t is unicode \ or (t is types.InstanceType and isinstance(e, UserString)) else: def cache_type_e_is_String(e): t = type(e) return t is str \ or (t is types.InstanceType and isinstance(e, UserString)) # Improved candidates that cache the type(e) result in a variable # before doing any checks, but using the global names for # DictType, ListType and StringType. def global_cache_type_e_is_Dict(e): t = type(e) return t is DictType or \ (t is InstanceType and isinstance(e, UserDict)) def global_cache_type_e_is_List(e): t = type(e) return t is ListType \ or (t is InstanceType and isinstance(e, UserList)) if UnicodeType is not None: def global_cache_type_e_is_String(e): t = type(e) return t is StringType \ or t is UnicodeType \ or (t is InstanceType and isinstance(e, UserString)) else: def global_cache_type_e_is_String(e): t = type(e) return t is StringType \ or (t is InstanceType and isinstance(e, UserString)) # Alternative that uses a myType() function to map the User* objects # to their corresponding underlying types. instanceTypeMap = { UserDict : dict, UserList : list, UserString : str, } if UnicodeType is not None: def myType(obj): t = type(obj) if t is types.InstanceType: t = instanceTypeMap.get(obj.__class__, t) elif t is unicode: t = str return t else: def myType(obj): t = type(obj) if t is types.InstanceType: t = instanceTypeMap.get(obj.__class__, t) return t def myType_is_Dict(e): return myType(e) is dict def myType_is_List(e): return myType(e) is list def myType_is_String(e): return myType(e) is str def Func01(obj): """original_is_String""" for i in IterationList: original_is_String(obj) def Func02(obj): """original_is_List""" for i in IterationList: original_is_List(obj) def Func03(obj): """original_is_Dict""" for i in IterationList: original_is_Dict(obj) def Func04(obj): """checkInstanceType_is_String""" for i in IterationList: checkInstanceType_is_String(obj) def Func05(obj): """checkInstanceType_is_List""" for i in IterationList: checkInstanceType_is_List(obj) def Func06(obj): """checkInstanceType_is_Dict""" for i in IterationList: checkInstanceType_is_Dict(obj) def Func07(obj): """cache_type_e_is_String""" for i in IterationList: cache_type_e_is_String(obj) def Func08(obj): """cache_type_e_is_List""" for i in IterationList: cache_type_e_is_List(obj) def Func09(obj): """cache_type_e_is_Dict""" for i in IterationList: cache_type_e_is_Dict(obj) def Func10(obj): """global_cache_type_e_is_String""" for i in IterationList: global_cache_type_e_is_String(obj) def Func11(obj): """global_cache_type_e_is_List""" for i in IterationList: global_cache_type_e_is_List(obj) def Func12(obj): """global_cache_type_e_is_Dict""" for i in IterationList: global_cache_type_e_is_Dict(obj) #def Func13(obj): # """myType_is_String""" # for i in IterationList: # myType_is_String(obj) # #def Func14(obj): # """myType_is_List""" # for i in IterationList: # myType_is_List(obj) # #def Func15(obj): # """myType_is_Dict""" # for i in IterationList: # myType_is_Dict(obj) # Data to pass to the functions on each run. Each entry is a # three-element tuple: # # ( # "Label to print describing this data run", # ('positional', 'arguments'), # {'keyword' : 'arguments'}, # ), class A: pass Data = [ ( "String", ('',), {}, ), ( "List", ([],), {}, ), ( "Dict", ({},), {}, ), ( "UserString", (UserString(''),), {}, ), ( "UserList", (UserList([]),), {}, ), ( "UserDict", (UserDict({}),), {}, ), ( "Object", (A(),), {}, ), ] # Local Variables: # tab-width:4 # indent-tabs-mode:nil # End: # vim: set expandtab tabstop=4 shiftwidth=4: